diff --git a/.gitignore b/.gitignore
index c89325b..93d6ee1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,11 @@
 !modules/**/
 !options/
 
+# release builds of the drivers (drivers/ivb/update.sh, pocl-gen7/release.sh)
+!drivers/
+!drivers/**/
+!drivers/**
+
 !flake.nix
 !flake.lock
 
diff --git a/drivers/ivb/SOURCE b/drivers/ivb/SOURCE
new file mode 100644
index 0000000..366afb0
--- /dev/null
+++ b/drivers/ivb/SOURCE
@@ -0,0 +1 @@
+065e4eb
diff --git a/drivers/ivb/i686/d3dadapter9.so.1 b/drivers/ivb/i686/d3dadapter9.so.1
new file mode 100755
index 0000000..05c5114
Binary files /dev/null and b/drivers/ivb/i686/d3dadapter9.so.1 differ
diff --git a/drivers/ivb/i686/libvulkan_intel_hasvk13.so b/drivers/ivb/i686/libvulkan_intel_hasvk13.so
new file mode 100755
index 0000000..331dcfa
Binary files /dev/null and b/drivers/ivb/i686/libvulkan_intel_hasvk13.so differ
diff --git a/drivers/ivb/update.sh b/drivers/ivb/update.sh
new file mode 100755
index 0000000..33085a0
--- /dev/null
+++ b/drivers/ivb/update.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# Copy the release build of the intel-hard-graphics mesa fork into this
+# directory; hw-ivb-drivers turns the files into the system's Vulkan (hasvk),
+# Direct3D 9 (gallium nine) and OpenCL (rusticl) drivers.
+#
+#   drivers/ivb/update.sh            ninja + install both release builds, copy
+#   nixos-rebuild switch             then
+#
+# The release builds are configured in the fork (meson setup release /
+# release32, see its flake's release shells, pinned to this system's nixpkgs).
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+fork=${IVB_FORK:-/mnt/HDD/linuxdata/Projects_XFS/Drivers/intel-hard-graphics}
+
+stage() { # build dir, profile, arch dir, files...
+  local build=$1 profile=$2 arch=$3
+  shift 3
+  local tmp
+  tmp=$(mktemp -d)
+  (cd "$fork" && nix develop ".profiles/$profile" -c ninja -C "$build" &&
+    nix develop ".profiles/$profile" -c meson install -C "$build" --no-rebuild \
+      --destdir "$tmp" --quiet)
+  mkdir -p "$here/$arch"
+  for f in "$@"; do
+    install -m 0755 "$tmp/usr/local/lib/$f" "$here/$arch/$(basename "$f")"
+  done
+  rm -rf "$tmp"
+}
+
+stage release release x86_64 \
+  libvulkan_intel_hasvk13.so d3d/d3dadapter9.so.1 libRusticlOpenCL.so.1
+stage release32 release-i686 i686 \
+  libvulkan_intel_hasvk13.so d3d/d3dadapter9.so.1
+
+(cd "$fork" && printf '%s\n' "$(jj log -r @- --no-graph -T 'commit_id.short() ++ " " ++ description.first_line()' 2>/dev/null ||
+  git rev-parse --short HEAD 2>/dev/null)") > "$here/SOURCE"
+ls -la "$here"/x86_64 "$here"/i686
+echo "source: $(cat "$here/SOURCE")"
diff --git a/drivers/ivb/x86_64/d3dadapter9.so.1 b/drivers/ivb/x86_64/d3dadapter9.so.1
new file mode 100755
index 0000000..be5670d
Binary files /dev/null and b/drivers/ivb/x86_64/d3dadapter9.so.1 differ
diff --git a/drivers/ivb/x86_64/libRusticlOpenCL.so.1 b/drivers/ivb/x86_64/libRusticlOpenCL.so.1
new file mode 100755
index 0000000..f46d7b3
Binary files /dev/null and b/drivers/ivb/x86_64/libRusticlOpenCL.so.1 differ
diff --git a/drivers/ivb/x86_64/libvulkan_intel_hasvk13.so b/drivers/ivb/x86_64/libvulkan_intel_hasvk13.so
new file mode 100755
index 0000000..beec307
Binary files /dev/null and b/drivers/ivb/x86_64/libvulkan_intel_hasvk13.so differ
diff --git a/drivers/pocl-gen7/SOURCE b/drivers/pocl-gen7/SOURCE
new file mode 100644
index 0000000..40870fa
--- /dev/null
+++ b/drivers/pocl-gen7/SOURCE
@@ -0,0 +1,2 @@
+pocl   844a8c5b9d19 gen7: find libgbe and beignet's library in ../beignet next to the installed driver (relocatable install)
+libgbe 90ae83634993 backend: OpenCL C 3.0 (-cl-std=CL3.0) on the 1.2 library
diff --git a/drivers/pocl-gen7/lib/beignet/beignet.bc b/drivers/pocl-gen7/lib/beignet/beignet.bc
new file mode 100644
index 0000000..e3be577
Binary files /dev/null and b/drivers/pocl-gen7/lib/beignet/beignet.bc differ
diff --git a/drivers/pocl-gen7/lib/beignet/beignet.pch b/drivers/pocl-gen7/lib/beignet/beignet.pch
new file mode 100644
index 0000000..a1d49c5
Binary files /dev/null and b/drivers/pocl-gen7/lib/beignet/beignet.pch differ
diff --git a/drivers/pocl-gen7/lib/beignet/beignet_20.bc b/drivers/pocl-gen7/lib/beignet/beignet_20.bc
new file mode 100644
index 0000000..985d794
Binary files /dev/null and b/drivers/pocl-gen7/lib/beignet/beignet_20.bc differ
diff --git a/drivers/pocl-gen7/lib/beignet/beignet_20.pch b/drivers/pocl-gen7/lib/beignet/beignet_20.pch
new file mode 100644
index 0000000..aa4fb83
Binary files /dev/null and b/drivers/pocl-gen7/lib/beignet/beignet_20.pch differ
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl.h b/drivers/pocl-gen7/lib/beignet/include/ocl.h
new file mode 100644
index 0000000..484562a
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_H__
+#define __OCL_H__
+
+/* LLVM 3.9 has these pre defined undef them first */
+#ifdef cl_khr_3d_image_writes
+#undef cl_khr_3d_image_writes
+#endif
+#ifdef cl_khr_byte_addressable_store
+#undef cl_khr_byte_addressable_store
+#endif
+#ifdef cl_khr_fp16
+#undef cl_khr_fp16
+#endif
+#ifdef cl_khr_fp64
+#undef cl_khr_fp64
+#endif
+#ifdef cl_khr_global_int32_base_atomics
+#undef cl_khr_global_int32_base_atomics
+#endif
+#ifdef cl_khr_global_int32_extended_atomics
+#undef cl_khr_global_int32_extended_atomics
+#endif
+#ifdef cl_khr_gl_sharing
+#undef cl_khr_gl_sharing
+#endif
+#ifdef cl_khr_icd
+#undef cl_khr_icd
+#endif
+#ifdef cl_khr_local_int32_base_atomics
+#undef cl_khr_local_int32_base_atomics
+#endif
+#ifdef cl_khr_local_int32_extended_atomics
+#undef cl_khr_local_int32_extended_atomics
+#endif
+
+#ifdef cl_khr_d3d10_sharing
+#undef cl_khr_d3d10_sharing
+#endif
+#ifdef cl_khr_gl_event
+#undef cl_khr_gl_event
+#endif
+#ifdef cl_khr_int64_base_atomics
+#undef cl_khr_int64_base_atomics
+#endif
+#ifdef cl_khr_int64_extended_atomics
+#undef cl_khr_int64_extended_atomics
+#endif
+
+#ifdef cl_khr_d3d11_sharing
+#undef cl_khr_d3d11_sharing
+#endif
+#ifdef cl_khr_depth_images
+#undef cl_khr_depth_images
+#endif
+#ifdef cl_khr_dx9_media_sharing
+#undef cl_khr_dx9_media_sharing
+#endif
+#ifdef cl_khr_gl_depth_images
+#undef cl_khr_gl_depth_images
+#endif
+#ifdef cl_khr_spir
+#undef cl_khr_spir
+#endif
+
+#include "ocl_defines.h"
+#include "ocl_types.h"
+#include "ocl_as.h"
+#include "ocl_async.h"
+#include "ocl_common.h"
+#include "ocl_convert.h"
+#include "ocl_float.h"
+#include "ocl_geometric.h"
+#include "ocl_image.h"
+#include "ocl_integer.h"
+#include "ocl_memcpy.h"
+#include "ocl_memset.h"
+#include "ocl_misc.h"
+#include "ocl_printf.h"
+#include "ocl_relational.h"
+#include "ocl_sync.h"
+#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300)
+#include "ocl_vload_20.h"
+#include "ocl_atom_20.h"
+#include "ocl_pipe.h"
+#include "ocl_math_20.h"
+#include "ocl_enqueue.h"
+#else
+#include "ocl_vload.h"
+#include "ocl_atom.h"
+#include "ocl_math.h"
+#endif
+#include "ocl_workitem.h"
+#include "ocl_simd.h"
+#include "ocl_work_group.h"
+
+/* Move these out from ocl_defines.h for only one define */
+#define cl_khr_global_int32_base_atomics
+#define cl_khr_global_int32_extended_atomics
+#define cl_khr_local_int32_base_atomics
+#define cl_khr_local_int32_extended_atomics
+#define cl_khr_byte_addressable_store
+#define cl_khr_icd
+#define cl_khr_gl_sharing
+#define cl_khr_spir
+#define cl_khr_fp16
+#define cl_khr_3d_image_writes
+#define cl_intel_subgroups
+#define cl_intel_subgroups_short
+#define cl_intel_planar_yuv
+#define cl_intel_media_block_io
+
+#if __clang_major__*10 + __clang_minor__ > 40
+#define cl_intel_required_subgroup_size
+#endif
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : disable
+#pragma OPENCL EXTENSION cl_khr_fp16 : disable
+/* OpenCL C 3.0: clang keeps fp64 on because this library declares double
+   functions; kernels must not see the feature the device lacks */
+#if (__OPENCL_C_VERSION__ >= 300)
+#undef __opencl_c_fp64
+#endif
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_as.h b/drivers/pocl-gen7/lib/beignet/include/ocl_as.h
new file mode 100644
index 0000000..6e2271f
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_as.h
@@ -0,0 +1,646 @@
+
+/*
+ * Copyright © 2012 - 2014 Intel Corporatio
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __OCL_AS_H__
+#define __OCL_AS_H__
+#include "ocl_types.h"
+
+OVERLOADABLE uchar as_uchar(char v);
+OVERLOADABLE char as_char(uchar v);
+OVERLOADABLE ushort as_ushort(short v);
+OVERLOADABLE char2 as_char2(short v);
+OVERLOADABLE uchar2 as_uchar2(short v);
+OVERLOADABLE half as_half(short v);
+OVERLOADABLE short as_short(ushort v);
+OVERLOADABLE char2 as_char2(ushort v);
+OVERLOADABLE uchar2 as_uchar2(ushort v);
+OVERLOADABLE half as_half(ushort v);
+OVERLOADABLE short as_short(char2 v);
+OVERLOADABLE ushort as_ushort(char2 v);
+OVERLOADABLE uchar2 as_uchar2(char2 v);
+OVERLOADABLE half as_half(char2 v);
+OVERLOADABLE short as_short(uchar2 v);
+OVERLOADABLE ushort as_ushort(uchar2 v);
+OVERLOADABLE char2 as_char2(uchar2 v);
+OVERLOADABLE half as_half(uchar2 v);
+OVERLOADABLE short as_short(half v);
+OVERLOADABLE ushort as_ushort(half v);
+OVERLOADABLE char2 as_char2(half v);
+OVERLOADABLE uchar2 as_uchar2(half v);
+OVERLOADABLE uint as_uint(int v);
+OVERLOADABLE short2 as_short2(int v);
+OVERLOADABLE ushort2 as_ushort2(int v);
+OVERLOADABLE char3 as_char3(int v);
+OVERLOADABLE char4 as_char4(int v);
+OVERLOADABLE uchar3 as_uchar3(int v);
+OVERLOADABLE uchar4 as_uchar4(int v);
+OVERLOADABLE float as_float(int v);
+OVERLOADABLE half2 as_half2(int v);
+OVERLOADABLE int as_int(uint v);
+OVERLOADABLE short2 as_short2(uint v);
+OVERLOADABLE ushort2 as_ushort2(uint v);
+OVERLOADABLE char3 as_char3(uint v);
+OVERLOADABLE char4 as_char4(uint v);
+OVERLOADABLE uchar3 as_uchar3(uint v);
+OVERLOADABLE uchar4 as_uchar4(uint v);
+OVERLOADABLE float as_float(uint v);
+OVERLOADABLE half2 as_half2(uint v);
+OVERLOADABLE int as_int(short2 v);
+OVERLOADABLE uint as_uint(short2 v);
+OVERLOADABLE ushort2 as_ushort2(short2 v);
+OVERLOADABLE char3 as_char3(short2 v);
+OVERLOADABLE char4 as_char4(short2 v);
+OVERLOADABLE uchar3 as_uchar3(short2 v);
+OVERLOADABLE uchar4 as_uchar4(short2 v);
+OVERLOADABLE float as_float(short2 v);
+OVERLOADABLE half2 as_half2(short2 v);
+OVERLOADABLE int as_int(ushort2 v);
+OVERLOADABLE uint as_uint(ushort2 v);
+OVERLOADABLE short2 as_short2(ushort2 v);
+OVERLOADABLE char3 as_char3(ushort2 v);
+OVERLOADABLE char4 as_char4(ushort2 v);
+OVERLOADABLE uchar3 as_uchar3(ushort2 v);
+OVERLOADABLE uchar4 as_uchar4(ushort2 v);
+OVERLOADABLE float as_float(ushort2 v);
+OVERLOADABLE half2 as_half2(ushort2 v);
+OVERLOADABLE int as_int(char3 v);
+OVERLOADABLE uint as_uint(char3 v);
+OVERLOADABLE short2 as_short2(char3 v);
+OVERLOADABLE ushort2 as_ushort2(char3 v);
+OVERLOADABLE uchar3 as_uchar3(char3 v);
+OVERLOADABLE uchar4 as_uchar4(char3 v);
+OVERLOADABLE float as_float(char3 v);
+OVERLOADABLE half2 as_half2(char3 v);
+OVERLOADABLE int as_int(char4 v);
+OVERLOADABLE uint as_uint(char4 v);
+OVERLOADABLE short2 as_short2(char4 v);
+OVERLOADABLE ushort2 as_ushort2(char4 v);
+OVERLOADABLE uchar3 as_uchar3(char4 v);
+OVERLOADABLE uchar4 as_uchar4(char4 v);
+OVERLOADABLE float as_float(char4 v);
+OVERLOADABLE half2 as_half2(char4 v);
+OVERLOADABLE int as_int(uchar3 v);
+OVERLOADABLE uint as_uint(uchar3 v);
+OVERLOADABLE short2 as_short2(uchar3 v);
+OVERLOADABLE ushort2 as_ushort2(uchar3 v);
+OVERLOADABLE char3 as_char3(uchar3 v);
+OVERLOADABLE char4 as_char4(uchar3 v);
+OVERLOADABLE float as_float(uchar3 v);
+OVERLOADABLE half2 as_half2(uchar3 v);
+OVERLOADABLE int as_int(uchar4 v);
+OVERLOADABLE uint as_uint(uchar4 v);
+OVERLOADABLE short2 as_short2(uchar4 v);
+OVERLOADABLE ushort2 as_ushort2(uchar4 v);
+OVERLOADABLE char3 as_char3(uchar4 v);
+OVERLOADABLE char4 as_char4(uchar4 v);
+OVERLOADABLE float as_float(uchar4 v);
+OVERLOADABLE half2 as_half2(uchar4 v);
+OVERLOADABLE int as_int(float v);
+OVERLOADABLE uint as_uint(float v);
+OVERLOADABLE short2 as_short2(float v);
+OVERLOADABLE ushort2 as_ushort2(float v);
+OVERLOADABLE char3 as_char3(float v);
+OVERLOADABLE char4 as_char4(float v);
+OVERLOADABLE uchar3 as_uchar3(float v);
+OVERLOADABLE uchar4 as_uchar4(float v);
+OVERLOADABLE half2 as_half2(float v);
+OVERLOADABLE int as_int(half2 v);
+OVERLOADABLE uint as_uint(half2 v);
+OVERLOADABLE short2 as_short2(half2 v);
+OVERLOADABLE ushort2 as_ushort2(half2 v);
+OVERLOADABLE char3 as_char3(half2 v);
+OVERLOADABLE char4 as_char4(half2 v);
+OVERLOADABLE uchar3 as_uchar3(half2 v);
+OVERLOADABLE uchar4 as_uchar4(half2 v);
+OVERLOADABLE float as_float(half2 v);
+OVERLOADABLE ulong as_ulong(long v);
+OVERLOADABLE int2 as_int2(long v);
+OVERLOADABLE uint2 as_uint2(long v);
+OVERLOADABLE short3 as_short3(long v);
+OVERLOADABLE short4 as_short4(long v);
+OVERLOADABLE ushort3 as_ushort3(long v);
+OVERLOADABLE ushort4 as_ushort4(long v);
+OVERLOADABLE char8 as_char8(long v);
+OVERLOADABLE uchar8 as_uchar8(long v);
+OVERLOADABLE double as_double(long v);
+OVERLOADABLE float2 as_float2(long v);
+OVERLOADABLE half3 as_half3(long v);
+OVERLOADABLE half4 as_half4(long v);
+OVERLOADABLE long as_long(ulong v);
+OVERLOADABLE int2 as_int2(ulong v);
+OVERLOADABLE uint2 as_uint2(ulong v);
+OVERLOADABLE short3 as_short3(ulong v);
+OVERLOADABLE short4 as_short4(ulong v);
+OVERLOADABLE ushort3 as_ushort3(ulong v);
+OVERLOADABLE ushort4 as_ushort4(ulong v);
+OVERLOADABLE char8 as_char8(ulong v);
+OVERLOADABLE uchar8 as_uchar8(ulong v);
+OVERLOADABLE double as_double(ulong v);
+OVERLOADABLE float2 as_float2(ulong v);
+OVERLOADABLE half3 as_half3(ulong v);
+OVERLOADABLE half4 as_half4(ulong v);
+OVERLOADABLE long as_long(int2 v);
+OVERLOADABLE ulong as_ulong(int2 v);
+OVERLOADABLE uint2 as_uint2(int2 v);
+OVERLOADABLE short3 as_short3(int2 v);
+OVERLOADABLE short4 as_short4(int2 v);
+OVERLOADABLE ushort3 as_ushort3(int2 v);
+OVERLOADABLE ushort4 as_ushort4(int2 v);
+OVERLOADABLE char8 as_char8(int2 v);
+OVERLOADABLE uchar8 as_uchar8(int2 v);
+OVERLOADABLE double as_double(int2 v);
+OVERLOADABLE float2 as_float2(int2 v);
+OVERLOADABLE half3 as_half3(int2 v);
+OVERLOADABLE half4 as_half4(int2 v);
+OVERLOADABLE long as_long(uint2 v);
+OVERLOADABLE ulong as_ulong(uint2 v);
+OVERLOADABLE int2 as_int2(uint2 v);
+OVERLOADABLE short3 as_short3(uint2 v);
+OVERLOADABLE short4 as_short4(uint2 v);
+OVERLOADABLE ushort3 as_ushort3(uint2 v);
+OVERLOADABLE ushort4 as_ushort4(uint2 v);
+OVERLOADABLE char8 as_char8(uint2 v);
+OVERLOADABLE uchar8 as_uchar8(uint2 v);
+OVERLOADABLE double as_double(uint2 v);
+OVERLOADABLE float2 as_float2(uint2 v);
+OVERLOADABLE half3 as_half3(uint2 v);
+OVERLOADABLE half4 as_half4(uint2 v);
+OVERLOADABLE long as_long(short3 v);
+OVERLOADABLE ulong as_ulong(short3 v);
+OVERLOADABLE int2 as_int2(short3 v);
+OVERLOADABLE uint2 as_uint2(short3 v);
+OVERLOADABLE ushort3 as_ushort3(short3 v);
+OVERLOADABLE ushort4 as_ushort4(short3 v);
+OVERLOADABLE char8 as_char8(short3 v);
+OVERLOADABLE uchar8 as_uchar8(short3 v);
+OVERLOADABLE double as_double(short3 v);
+OVERLOADABLE float2 as_float2(short3 v);
+OVERLOADABLE half3 as_half3(short3 v);
+OVERLOADABLE half4 as_half4(short3 v);
+OVERLOADABLE long as_long(short4 v);
+OVERLOADABLE ulong as_ulong(short4 v);
+OVERLOADABLE int2 as_int2(short4 v);
+OVERLOADABLE uint2 as_uint2(short4 v);
+OVERLOADABLE ushort3 as_ushort3(short4 v);
+OVERLOADABLE ushort4 as_ushort4(short4 v);
+OVERLOADABLE char8 as_char8(short4 v);
+OVERLOADABLE uchar8 as_uchar8(short4 v);
+OVERLOADABLE double as_double(short4 v);
+OVERLOADABLE float2 as_float2(short4 v);
+OVERLOADABLE half3 as_half3(short4 v);
+OVERLOADABLE half4 as_half4(short4 v);
+OVERLOADABLE long as_long(ushort3 v);
+OVERLOADABLE ulong as_ulong(ushort3 v);
+OVERLOADABLE int2 as_int2(ushort3 v);
+OVERLOADABLE uint2 as_uint2(ushort3 v);
+OVERLOADABLE short3 as_short3(ushort3 v);
+OVERLOADABLE short4 as_short4(ushort3 v);
+OVERLOADABLE char8 as_char8(ushort3 v);
+OVERLOADABLE uchar8 as_uchar8(ushort3 v);
+OVERLOADABLE double as_double(ushort3 v);
+OVERLOADABLE float2 as_float2(ushort3 v);
+OVERLOADABLE half3 as_half3(ushort3 v);
+OVERLOADABLE half4 as_half4(ushort3 v);
+OVERLOADABLE long as_long(ushort4 v);
+OVERLOADABLE ulong as_ulong(ushort4 v);
+OVERLOADABLE int2 as_int2(ushort4 v);
+OVERLOADABLE uint2 as_uint2(ushort4 v);
+OVERLOADABLE short3 as_short3(ushort4 v);
+OVERLOADABLE short4 as_short4(ushort4 v);
+OVERLOADABLE char8 as_char8(ushort4 v);
+OVERLOADABLE uchar8 as_uchar8(ushort4 v);
+OVERLOADABLE double as_double(ushort4 v);
+OVERLOADABLE float2 as_float2(ushort4 v);
+OVERLOADABLE half3 as_half3(ushort4 v);
+OVERLOADABLE half4 as_half4(ushort4 v);
+OVERLOADABLE long as_long(char8 v);
+OVERLOADABLE ulong as_ulong(char8 v);
+OVERLOADABLE int2 as_int2(char8 v);
+OVERLOADABLE uint2 as_uint2(char8 v);
+OVERLOADABLE short3 as_short3(char8 v);
+OVERLOADABLE short4 as_short4(char8 v);
+OVERLOADABLE ushort3 as_ushort3(char8 v);
+OVERLOADABLE ushort4 as_ushort4(char8 v);
+OVERLOADABLE uchar8 as_uchar8(char8 v);
+OVERLOADABLE double as_double(char8 v);
+OVERLOADABLE float2 as_float2(char8 v);
+OVERLOADABLE half3 as_half3(char8 v);
+OVERLOADABLE half4 as_half4(char8 v);
+OVERLOADABLE long as_long(uchar8 v);
+OVERLOADABLE ulong as_ulong(uchar8 v);
+OVERLOADABLE int2 as_int2(uchar8 v);
+OVERLOADABLE uint2 as_uint2(uchar8 v);
+OVERLOADABLE short3 as_short3(uchar8 v);
+OVERLOADABLE short4 as_short4(uchar8 v);
+OVERLOADABLE ushort3 as_ushort3(uchar8 v);
+OVERLOADABLE ushort4 as_ushort4(uchar8 v);
+OVERLOADABLE char8 as_char8(uchar8 v);
+OVERLOADABLE double as_double(uchar8 v);
+OVERLOADABLE float2 as_float2(uchar8 v);
+OVERLOADABLE half3 as_half3(uchar8 v);
+OVERLOADABLE half4 as_half4(uchar8 v);
+OVERLOADABLE long as_long(double v);
+OVERLOADABLE ulong as_ulong(double v);
+OVERLOADABLE int2 as_int2(double v);
+OVERLOADABLE uint2 as_uint2(double v);
+OVERLOADABLE short3 as_short3(double v);
+OVERLOADABLE short4 as_short4(double v);
+OVERLOADABLE ushort3 as_ushort3(double v);
+OVERLOADABLE ushort4 as_ushort4(double v);
+OVERLOADABLE char8 as_char8(double v);
+OVERLOADABLE uchar8 as_uchar8(double v);
+OVERLOADABLE float2 as_float2(double v);
+OVERLOADABLE half3 as_half3(double v);
+OVERLOADABLE half4 as_half4(double v);
+OVERLOADABLE long as_long(float2 v);
+OVERLOADABLE ulong as_ulong(float2 v);
+OVERLOADABLE int2 as_int2(float2 v);
+OVERLOADABLE uint2 as_uint2(float2 v);
+OVERLOADABLE short3 as_short3(float2 v);
+OVERLOADABLE short4 as_short4(float2 v);
+OVERLOADABLE ushort3 as_ushort3(float2 v);
+OVERLOADABLE ushort4 as_ushort4(float2 v);
+OVERLOADABLE char8 as_char8(float2 v);
+OVERLOADABLE uchar8 as_uchar8(float2 v);
+OVERLOADABLE double as_double(float2 v);
+OVERLOADABLE half3 as_half3(float2 v);
+OVERLOADABLE half4 as_half4(float2 v);
+OVERLOADABLE long as_long(half3 v);
+OVERLOADABLE ulong as_ulong(half3 v);
+OVERLOADABLE int2 as_int2(half3 v);
+OVERLOADABLE uint2 as_uint2(half3 v);
+OVERLOADABLE short3 as_short3(half3 v);
+OVERLOADABLE short4 as_short4(half3 v);
+OVERLOADABLE ushort3 as_ushort3(half3 v);
+OVERLOADABLE ushort4 as_ushort4(half3 v);
+OVERLOADABLE char8 as_char8(half3 v);
+OVERLOADABLE uchar8 as_uchar8(half3 v);
+OVERLOADABLE double as_double(half3 v);
+OVERLOADABLE float2 as_float2(half3 v);
+OVERLOADABLE long as_long(half4 v);
+OVERLOADABLE ulong as_ulong(half4 v);
+OVERLOADABLE int2 as_int2(half4 v);
+OVERLOADABLE uint2 as_uint2(half4 v);
+OVERLOADABLE short3 as_short3(half4 v);
+OVERLOADABLE short4 as_short4(half4 v);
+OVERLOADABLE ushort3 as_ushort3(half4 v);
+OVERLOADABLE ushort4 as_ushort4(half4 v);
+OVERLOADABLE char8 as_char8(half4 v);
+OVERLOADABLE uchar8 as_uchar8(half4 v);
+OVERLOADABLE double as_double(half4 v);
+OVERLOADABLE float2 as_float2(half4 v);
+OVERLOADABLE ulong2 as_ulong2(long2 v);
+OVERLOADABLE int3 as_int3(long2 v);
+OVERLOADABLE int4 as_int4(long2 v);
+OVERLOADABLE uint3 as_uint3(long2 v);
+OVERLOADABLE uint4 as_uint4(long2 v);
+OVERLOADABLE short8 as_short8(long2 v);
+OVERLOADABLE ushort8 as_ushort8(long2 v);
+OVERLOADABLE char16 as_char16(long2 v);
+OVERLOADABLE uchar16 as_uchar16(long2 v);
+OVERLOADABLE double2 as_double2(long2 v);
+OVERLOADABLE float3 as_float3(long2 v);
+OVERLOADABLE float4 as_float4(long2 v);
+OVERLOADABLE half8 as_half8(long2 v);
+OVERLOADABLE long2 as_long2(ulong2 v);
+OVERLOADABLE int3 as_int3(ulong2 v);
+OVERLOADABLE int4 as_int4(ulong2 v);
+OVERLOADABLE uint3 as_uint3(ulong2 v);
+OVERLOADABLE uint4 as_uint4(ulong2 v);
+OVERLOADABLE short8 as_short8(ulong2 v);
+OVERLOADABLE ushort8 as_ushort8(ulong2 v);
+OVERLOADABLE char16 as_char16(ulong2 v);
+OVERLOADABLE uchar16 as_uchar16(ulong2 v);
+OVERLOADABLE double2 as_double2(ulong2 v);
+OVERLOADABLE float3 as_float3(ulong2 v);
+OVERLOADABLE float4 as_float4(ulong2 v);
+OVERLOADABLE half8 as_half8(ulong2 v);
+OVERLOADABLE long2 as_long2(int3 v);
+OVERLOADABLE ulong2 as_ulong2(int3 v);
+OVERLOADABLE uint3 as_uint3(int3 v);
+OVERLOADABLE uint4 as_uint4(int3 v);
+OVERLOADABLE short8 as_short8(int3 v);
+OVERLOADABLE ushort8 as_ushort8(int3 v);
+OVERLOADABLE char16 as_char16(int3 v);
+OVERLOADABLE uchar16 as_uchar16(int3 v);
+OVERLOADABLE double2 as_double2(int3 v);
+OVERLOADABLE float3 as_float3(int3 v);
+OVERLOADABLE float4 as_float4(int3 v);
+OVERLOADABLE half8 as_half8(int3 v);
+OVERLOADABLE long2 as_long2(int4 v);
+OVERLOADABLE ulong2 as_ulong2(int4 v);
+OVERLOADABLE uint3 as_uint3(int4 v);
+OVERLOADABLE uint4 as_uint4(int4 v);
+OVERLOADABLE short8 as_short8(int4 v);
+OVERLOADABLE ushort8 as_ushort8(int4 v);
+OVERLOADABLE char16 as_char16(int4 v);
+OVERLOADABLE uchar16 as_uchar16(int4 v);
+OVERLOADABLE double2 as_double2(int4 v);
+OVERLOADABLE float3 as_float3(int4 v);
+OVERLOADABLE float4 as_float4(int4 v);
+OVERLOADABLE half8 as_half8(int4 v);
+OVERLOADABLE long2 as_long2(uint3 v);
+OVERLOADABLE ulong2 as_ulong2(uint3 v);
+OVERLOADABLE int3 as_int3(uint3 v);
+OVERLOADABLE int4 as_int4(uint3 v);
+OVERLOADABLE short8 as_short8(uint3 v);
+OVERLOADABLE ushort8 as_ushort8(uint3 v);
+OVERLOADABLE char16 as_char16(uint3 v);
+OVERLOADABLE uchar16 as_uchar16(uint3 v);
+OVERLOADABLE double2 as_double2(uint3 v);
+OVERLOADABLE float3 as_float3(uint3 v);
+OVERLOADABLE float4 as_float4(uint3 v);
+OVERLOADABLE half8 as_half8(uint3 v);
+OVERLOADABLE long2 as_long2(uint4 v);
+OVERLOADABLE ulong2 as_ulong2(uint4 v);
+OVERLOADABLE int3 as_int3(uint4 v);
+OVERLOADABLE int4 as_int4(uint4 v);
+OVERLOADABLE short8 as_short8(uint4 v);
+OVERLOADABLE ushort8 as_ushort8(uint4 v);
+OVERLOADABLE char16 as_char16(uint4 v);
+OVERLOADABLE uchar16 as_uchar16(uint4 v);
+OVERLOADABLE double2 as_double2(uint4 v);
+OVERLOADABLE float3 as_float3(uint4 v);
+OVERLOADABLE float4 as_float4(uint4 v);
+OVERLOADABLE half8 as_half8(uint4 v);
+OVERLOADABLE long2 as_long2(short8 v);
+OVERLOADABLE ulong2 as_ulong2(short8 v);
+OVERLOADABLE int3 as_int3(short8 v);
+OVERLOADABLE int4 as_int4(short8 v);
+OVERLOADABLE uint3 as_uint3(short8 v);
+OVERLOADABLE uint4 as_uint4(short8 v);
+OVERLOADABLE ushort8 as_ushort8(short8 v);
+OVERLOADABLE char16 as_char16(short8 v);
+OVERLOADABLE uchar16 as_uchar16(short8 v);
+OVERLOADABLE double2 as_double2(short8 v);
+OVERLOADABLE float3 as_float3(short8 v);
+OVERLOADABLE float4 as_float4(short8 v);
+OVERLOADABLE half8 as_half8(short8 v);
+OVERLOADABLE long2 as_long2(ushort8 v);
+OVERLOADABLE ulong2 as_ulong2(ushort8 v);
+OVERLOADABLE int3 as_int3(ushort8 v);
+OVERLOADABLE int4 as_int4(ushort8 v);
+OVERLOADABLE uint3 as_uint3(ushort8 v);
+OVERLOADABLE uint4 as_uint4(ushort8 v);
+OVERLOADABLE short8 as_short8(ushort8 v);
+OVERLOADABLE char16 as_char16(ushort8 v);
+OVERLOADABLE uchar16 as_uchar16(ushort8 v);
+OVERLOADABLE double2 as_double2(ushort8 v);
+OVERLOADABLE float3 as_float3(ushort8 v);
+OVERLOADABLE float4 as_float4(ushort8 v);
+OVERLOADABLE half8 as_half8(ushort8 v);
+OVERLOADABLE long2 as_long2(char16 v);
+OVERLOADABLE ulong2 as_ulong2(char16 v);
+OVERLOADABLE int3 as_int3(char16 v);
+OVERLOADABLE int4 as_int4(char16 v);
+OVERLOADABLE uint3 as_uint3(char16 v);
+OVERLOADABLE uint4 as_uint4(char16 v);
+OVERLOADABLE short8 as_short8(char16 v);
+OVERLOADABLE ushort8 as_ushort8(char16 v);
+OVERLOADABLE uchar16 as_uchar16(char16 v);
+OVERLOADABLE double2 as_double2(char16 v);
+OVERLOADABLE float3 as_float3(char16 v);
+OVERLOADABLE float4 as_float4(char16 v);
+OVERLOADABLE half8 as_half8(char16 v);
+OVERLOADABLE long2 as_long2(uchar16 v);
+OVERLOADABLE ulong2 as_ulong2(uchar16 v);
+OVERLOADABLE int3 as_int3(uchar16 v);
+OVERLOADABLE int4 as_int4(uchar16 v);
+OVERLOADABLE uint3 as_uint3(uchar16 v);
+OVERLOADABLE uint4 as_uint4(uchar16 v);
+OVERLOADABLE short8 as_short8(uchar16 v);
+OVERLOADABLE ushort8 as_ushort8(uchar16 v);
+OVERLOADABLE char16 as_char16(uchar16 v);
+OVERLOADABLE double2 as_double2(uchar16 v);
+OVERLOADABLE float3 as_float3(uchar16 v);
+OVERLOADABLE float4 as_float4(uchar16 v);
+OVERLOADABLE half8 as_half8(uchar16 v);
+OVERLOADABLE long2 as_long2(double2 v);
+OVERLOADABLE ulong2 as_ulong2(double2 v);
+OVERLOADABLE int3 as_int3(double2 v);
+OVERLOADABLE int4 as_int4(double2 v);
+OVERLOADABLE uint3 as_uint3(double2 v);
+OVERLOADABLE uint4 as_uint4(double2 v);
+OVERLOADABLE short8 as_short8(double2 v);
+OVERLOADABLE ushort8 as_ushort8(double2 v);
+OVERLOADABLE char16 as_char16(double2 v);
+OVERLOADABLE uchar16 as_uchar16(double2 v);
+OVERLOADABLE float3 as_float3(double2 v);
+OVERLOADABLE float4 as_float4(double2 v);
+OVERLOADABLE half8 as_half8(double2 v);
+OVERLOADABLE long2 as_long2(float3 v);
+OVERLOADABLE ulong2 as_ulong2(float3 v);
+OVERLOADABLE int3 as_int3(float3 v);
+OVERLOADABLE int4 as_int4(float3 v);
+OVERLOADABLE uint3 as_uint3(float3 v);
+OVERLOADABLE uint4 as_uint4(float3 v);
+OVERLOADABLE short8 as_short8(float3 v);
+OVERLOADABLE ushort8 as_ushort8(float3 v);
+OVERLOADABLE char16 as_char16(float3 v);
+OVERLOADABLE uchar16 as_uchar16(float3 v);
+OVERLOADABLE double2 as_double2(float3 v);
+OVERLOADABLE half8 as_half8(float3 v);
+OVERLOADABLE long2 as_long2(float4 v);
+OVERLOADABLE ulong2 as_ulong2(float4 v);
+OVERLOADABLE int3 as_int3(float4 v);
+OVERLOADABLE int4 as_int4(float4 v);
+OVERLOADABLE uint3 as_uint3(float4 v);
+OVERLOADABLE uint4 as_uint4(float4 v);
+OVERLOADABLE short8 as_short8(float4 v);
+OVERLOADABLE ushort8 as_ushort8(float4 v);
+OVERLOADABLE char16 as_char16(float4 v);
+OVERLOADABLE uchar16 as_uchar16(float4 v);
+OVERLOADABLE double2 as_double2(float4 v);
+OVERLOADABLE half8 as_half8(float4 v);
+OVERLOADABLE long2 as_long2(half8 v);
+OVERLOADABLE ulong2 as_ulong2(half8 v);
+OVERLOADABLE int3 as_int3(half8 v);
+OVERLOADABLE int4 as_int4(half8 v);
+OVERLOADABLE uint3 as_uint3(half8 v);
+OVERLOADABLE uint4 as_uint4(half8 v);
+OVERLOADABLE short8 as_short8(half8 v);
+OVERLOADABLE ushort8 as_ushort8(half8 v);
+OVERLOADABLE char16 as_char16(half8 v);
+OVERLOADABLE uchar16 as_uchar16(half8 v);
+OVERLOADABLE double2 as_double2(half8 v);
+OVERLOADABLE float3 as_float3(half8 v);
+OVERLOADABLE float4 as_float4(half8 v);
+OVERLOADABLE ulong3 as_ulong3(long3 v);
+OVERLOADABLE ulong4 as_ulong4(long3 v);
+OVERLOADABLE int8 as_int8(long3 v);
+OVERLOADABLE uint8 as_uint8(long3 v);
+OVERLOADABLE short16 as_short16(long3 v);
+OVERLOADABLE ushort16 as_ushort16(long3 v);
+OVERLOADABLE double3 as_double3(long3 v);
+OVERLOADABLE double4 as_double4(long3 v);
+OVERLOADABLE float8 as_float8(long3 v);
+OVERLOADABLE half16 as_half16(long3 v);
+OVERLOADABLE ulong3 as_ulong3(long4 v);
+OVERLOADABLE ulong4 as_ulong4(long4 v);
+OVERLOADABLE int8 as_int8(long4 v);
+OVERLOADABLE uint8 as_uint8(long4 v);
+OVERLOADABLE short16 as_short16(long4 v);
+OVERLOADABLE ushort16 as_ushort16(long4 v);
+OVERLOADABLE double3 as_double3(long4 v);
+OVERLOADABLE double4 as_double4(long4 v);
+OVERLOADABLE float8 as_float8(long4 v);
+OVERLOADABLE half16 as_half16(long4 v);
+OVERLOADABLE long3 as_long3(ulong3 v);
+OVERLOADABLE long4 as_long4(ulong3 v);
+OVERLOADABLE int8 as_int8(ulong3 v);
+OVERLOADABLE uint8 as_uint8(ulong3 v);
+OVERLOADABLE short16 as_short16(ulong3 v);
+OVERLOADABLE ushort16 as_ushort16(ulong3 v);
+OVERLOADABLE double3 as_double3(ulong3 v);
+OVERLOADABLE double4 as_double4(ulong3 v);
+OVERLOADABLE float8 as_float8(ulong3 v);
+OVERLOADABLE half16 as_half16(ulong3 v);
+OVERLOADABLE long3 as_long3(ulong4 v);
+OVERLOADABLE long4 as_long4(ulong4 v);
+OVERLOADABLE int8 as_int8(ulong4 v);
+OVERLOADABLE uint8 as_uint8(ulong4 v);
+OVERLOADABLE short16 as_short16(ulong4 v);
+OVERLOADABLE ushort16 as_ushort16(ulong4 v);
+OVERLOADABLE double3 as_double3(ulong4 v);
+OVERLOADABLE double4 as_double4(ulong4 v);
+OVERLOADABLE float8 as_float8(ulong4 v);
+OVERLOADABLE half16 as_half16(ulong4 v);
+OVERLOADABLE long3 as_long3(int8 v);
+OVERLOADABLE long4 as_long4(int8 v);
+OVERLOADABLE ulong3 as_ulong3(int8 v);
+OVERLOADABLE ulong4 as_ulong4(int8 v);
+OVERLOADABLE uint8 as_uint8(int8 v);
+OVERLOADABLE short16 as_short16(int8 v);
+OVERLOADABLE ushort16 as_ushort16(int8 v);
+OVERLOADABLE double3 as_double3(int8 v);
+OVERLOADABLE double4 as_double4(int8 v);
+OVERLOADABLE float8 as_float8(int8 v);
+OVERLOADABLE half16 as_half16(int8 v);
+OVERLOADABLE long3 as_long3(uint8 v);
+OVERLOADABLE long4 as_long4(uint8 v);
+OVERLOADABLE ulong3 as_ulong3(uint8 v);
+OVERLOADABLE ulong4 as_ulong4(uint8 v);
+OVERLOADABLE int8 as_int8(uint8 v);
+OVERLOADABLE short16 as_short16(uint8 v);
+OVERLOADABLE ushort16 as_ushort16(uint8 v);
+OVERLOADABLE double3 as_double3(uint8 v);
+OVERLOADABLE double4 as_double4(uint8 v);
+OVERLOADABLE float8 as_float8(uint8 v);
+OVERLOADABLE half16 as_half16(uint8 v);
+OVERLOADABLE long3 as_long3(short16 v);
+OVERLOADABLE long4 as_long4(short16 v);
+OVERLOADABLE ulong3 as_ulong3(short16 v);
+OVERLOADABLE ulong4 as_ulong4(short16 v);
+OVERLOADABLE int8 as_int8(short16 v);
+OVERLOADABLE uint8 as_uint8(short16 v);
+OVERLOADABLE ushort16 as_ushort16(short16 v);
+OVERLOADABLE double3 as_double3(short16 v);
+OVERLOADABLE double4 as_double4(short16 v);
+OVERLOADABLE float8 as_float8(short16 v);
+OVERLOADABLE half16 as_half16(short16 v);
+OVERLOADABLE long3 as_long3(ushort16 v);
+OVERLOADABLE long4 as_long4(ushort16 v);
+OVERLOADABLE ulong3 as_ulong3(ushort16 v);
+OVERLOADABLE ulong4 as_ulong4(ushort16 v);
+OVERLOADABLE int8 as_int8(ushort16 v);
+OVERLOADABLE uint8 as_uint8(ushort16 v);
+OVERLOADABLE short16 as_short16(ushort16 v);
+OVERLOADABLE double3 as_double3(ushort16 v);
+OVERLOADABLE double4 as_double4(ushort16 v);
+OVERLOADABLE float8 as_float8(ushort16 v);
+OVERLOADABLE half16 as_half16(ushort16 v);
+OVERLOADABLE long3 as_long3(double3 v);
+OVERLOADABLE long4 as_long4(double3 v);
+OVERLOADABLE ulong3 as_ulong3(double3 v);
+OVERLOADABLE ulong4 as_ulong4(double3 v);
+OVERLOADABLE int8 as_int8(double3 v);
+OVERLOADABLE uint8 as_uint8(double3 v);
+OVERLOADABLE short16 as_short16(double3 v);
+OVERLOADABLE ushort16 as_ushort16(double3 v);
+OVERLOADABLE float8 as_float8(double3 v);
+OVERLOADABLE half16 as_half16(double3 v);
+OVERLOADABLE long3 as_long3(double4 v);
+OVERLOADABLE long4 as_long4(double4 v);
+OVERLOADABLE ulong3 as_ulong3(double4 v);
+OVERLOADABLE ulong4 as_ulong4(double4 v);
+OVERLOADABLE int8 as_int8(double4 v);
+OVERLOADABLE uint8 as_uint8(double4 v);
+OVERLOADABLE short16 as_short16(double4 v);
+OVERLOADABLE ushort16 as_ushort16(double4 v);
+OVERLOADABLE float8 as_float8(double4 v);
+OVERLOADABLE half16 as_half16(double4 v);
+OVERLOADABLE long3 as_long3(float8 v);
+OVERLOADABLE long4 as_long4(float8 v);
+OVERLOADABLE ulong3 as_ulong3(float8 v);
+OVERLOADABLE ulong4 as_ulong4(float8 v);
+OVERLOADABLE int8 as_int8(float8 v);
+OVERLOADABLE uint8 as_uint8(float8 v);
+OVERLOADABLE short16 as_short16(float8 v);
+OVERLOADABLE ushort16 as_ushort16(float8 v);
+OVERLOADABLE double3 as_double3(float8 v);
+OVERLOADABLE double4 as_double4(float8 v);
+OVERLOADABLE half16 as_half16(float8 v);
+OVERLOADABLE long3 as_long3(half16 v);
+OVERLOADABLE long4 as_long4(half16 v);
+OVERLOADABLE ulong3 as_ulong3(half16 v);
+OVERLOADABLE ulong4 as_ulong4(half16 v);
+OVERLOADABLE int8 as_int8(half16 v);
+OVERLOADABLE uint8 as_uint8(half16 v);
+OVERLOADABLE short16 as_short16(half16 v);
+OVERLOADABLE ushort16 as_ushort16(half16 v);
+OVERLOADABLE double3 as_double3(half16 v);
+OVERLOADABLE double4 as_double4(half16 v);
+OVERLOADABLE float8 as_float8(half16 v);
+OVERLOADABLE ulong8 as_ulong8(long8 v);
+OVERLOADABLE int16 as_int16(long8 v);
+OVERLOADABLE uint16 as_uint16(long8 v);
+OVERLOADABLE double8 as_double8(long8 v);
+OVERLOADABLE float16 as_float16(long8 v);
+OVERLOADABLE long8 as_long8(ulong8 v);
+OVERLOADABLE int16 as_int16(ulong8 v);
+OVERLOADABLE uint16 as_uint16(ulong8 v);
+OVERLOADABLE double8 as_double8(ulong8 v);
+OVERLOADABLE float16 as_float16(ulong8 v);
+OVERLOADABLE long8 as_long8(int16 v);
+OVERLOADABLE ulong8 as_ulong8(int16 v);
+OVERLOADABLE uint16 as_uint16(int16 v);
+OVERLOADABLE double8 as_double8(int16 v);
+OVERLOADABLE float16 as_float16(int16 v);
+OVERLOADABLE long8 as_long8(uint16 v);
+OVERLOADABLE ulong8 as_ulong8(uint16 v);
+OVERLOADABLE int16 as_int16(uint16 v);
+OVERLOADABLE double8 as_double8(uint16 v);
+OVERLOADABLE float16 as_float16(uint16 v);
+OVERLOADABLE long8 as_long8(double8 v);
+OVERLOADABLE ulong8 as_ulong8(double8 v);
+OVERLOADABLE int16 as_int16(double8 v);
+OVERLOADABLE uint16 as_uint16(double8 v);
+OVERLOADABLE float16 as_float16(double8 v);
+OVERLOADABLE long8 as_long8(float16 v);
+OVERLOADABLE ulong8 as_ulong8(float16 v);
+OVERLOADABLE int16 as_int16(float16 v);
+OVERLOADABLE uint16 as_uint16(float16 v);
+OVERLOADABLE double8 as_double8(float16 v);
+OVERLOADABLE ulong16 as_ulong16(long16 v);
+OVERLOADABLE double16 as_double16(long16 v);
+OVERLOADABLE long16 as_long16(ulong16 v);
+OVERLOADABLE double16 as_double16(ulong16 v);
+OVERLOADABLE long16 as_long16(double16 v);
+OVERLOADABLE ulong16 as_ulong16(double16 v);
+#endif /* __OCL_AS_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_async.h b/drivers/pocl-gen7/lib/beignet/include/ocl_async.h
new file mode 100644
index 0000000..6e49bcd
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_async.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_ASYNC_H__
+#define __OCL_ASYNC_H__
+
+#include "ocl_types.h"
+
+#define DEFN(TYPE) \
+OVERLOADABLE event_t async_work_group_copy (local TYPE *dst,  const global TYPE *src, \
+							 size_t num, event_t event); \
+OVERLOADABLE event_t async_work_group_copy (global TYPE *dst,  const local TYPE *src, \
+							  size_t num, event_t event); \
+OVERLOADABLE event_t async_work_group_strided_copy (local TYPE *dst,  const global TYPE *src, \
+								 size_t num, size_t src_stride, event_t event); \
+OVERLOADABLE event_t async_work_group_strided_copy (global TYPE *dst,  const local TYPE *src, \
+								  size_t num, size_t dst_stride, event_t event); \
+
+#define DEF(TYPE) \
+  DEFN(TYPE); DEFN(TYPE##2); DEFN(TYPE##3); DEFN(TYPE##4); DEFN(TYPE##8); DEFN(TYPE##16);
+DEF(char)
+DEF(uchar)
+DEF(short)
+DEF(ushort)
+DEF(int)
+DEF(uint)
+DEF(long)
+DEF(ulong)
+DEF(float)
+DEF(double)
+#undef DEFN
+#undef DEF
+
+OVERLOADABLE void wait_group_events (int num_events, event_t *event_list);
+
+#define DEFN(TYPE) \
+OVERLOADABLE void prefetch(const global TYPE *p, size_t num);
+#define DEF(TYPE) \
+DEFN(TYPE); DEFN(TYPE##2); DEFN(TYPE##3); DEFN(TYPE##4); DEFN(TYPE##8); DEFN(TYPE##16)
+DEF(char);
+DEF(uchar);
+DEF(short);
+DEF(ushort);
+DEF(int);
+DEF(uint);
+DEF(long);
+DEF(ulong);
+DEF(float);
+DEF(double);
+#undef DEFN
+#undef DEF
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_atom.h b/drivers/pocl-gen7/lib/beignet/include/ocl_atom.h
new file mode 100644
index 0000000..d0f6b10
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_atom.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_ATOM_H__
+#define __OCL_ATOM_H__
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Atomic functions
+/////////////////////////////////////////////////////////////////////////////
+
+OVERLOADABLE uint atomic_add(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_add(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_add(volatile __global int *p, int val);
+OVERLOADABLE int atomic_add(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_sub(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_sub(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_sub(volatile __global int *p, int val);
+OVERLOADABLE int atomic_sub(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_and(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_and(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_and(volatile __global int *p, int val);
+OVERLOADABLE int atomic_and(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_or(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_or(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_or(volatile __global int *p, int val);
+OVERLOADABLE int atomic_or(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_xor(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_xor(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_xor(volatile __global int *p, int val);
+OVERLOADABLE int atomic_xor(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_xchg(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_xchg(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_xchg(volatile __global int *p, int val);
+OVERLOADABLE int atomic_xchg(volatile __local int *p, int val);
+
+OVERLOADABLE int atomic_min(volatile __global int *p, int val);
+OVERLOADABLE int atomic_min(volatile __local int *p, int val);
+
+OVERLOADABLE int atomic_max(volatile __global int *p, int val);
+OVERLOADABLE int atomic_max(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_min(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_min(volatile __local uint *p, uint val);
+
+OVERLOADABLE uint atomic_max(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_max(volatile __local uint *p, uint val);
+
+OVERLOADABLE float atomic_xchg (volatile __global float *p, float val);
+OVERLOADABLE float atomic_xchg (volatile __local float *p, float val);
+
+OVERLOADABLE uint atomic_inc (volatile __global uint *p);
+OVERLOADABLE uint atomic_inc (volatile __local uint *p);
+OVERLOADABLE int atomic_inc (volatile __global int *p);
+OVERLOADABLE int atomic_inc (volatile __local int *p);
+
+OVERLOADABLE uint atomic_dec (volatile __global uint *p);
+OVERLOADABLE uint atomic_dec (volatile __local uint *p);
+OVERLOADABLE int atomic_dec (volatile __global int *p);
+OVERLOADABLE int atomic_dec (volatile __local int *p);
+
+OVERLOADABLE uint atomic_cmpxchg (volatile __global uint *p, uint cmp, uint val);
+OVERLOADABLE uint atomic_cmpxchg (volatile __local uint *p, uint cmp, uint val);
+OVERLOADABLE int atomic_cmpxchg (volatile __global int *p, int cmp, int val);
+OVERLOADABLE int atomic_cmpxchg (volatile __local int *p, int cmp, int val);
+
+
+// XXX for conformance test
+// The following atom_xxx api is on OpenCL spec 1.0.
+#define atom_add atomic_add
+#define atom_sub atomic_sub
+#define atom_and atomic_and
+#define atom_or atomic_or
+#define atom_xor atomic_xor
+#define atom_xchg atomic_xchg
+#define atom_min atomic_min
+#define atom_max atomic_max
+#define atom_inc atomic_inc
+#define atom_dec atomic_dec
+#define atom_cmpxchg atomic_cmpxchg
+
+
+#endif  /* __OCL_ATOM_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_atom_20.h b/drivers/pocl-gen7/lib/beignet/include/ocl_atom_20.h
new file mode 100644
index 0000000..9e34c31
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_atom_20.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_ATOM20_H__
+#define __OCL_ATOM20_H__
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Atomic functions
+/////////////////////////////////////////////////////////////////////////////
+
+OVERLOADABLE uint atomic_add(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_add(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_add(volatile __global int *p, int val);
+OVERLOADABLE int atomic_add(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_sub(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_sub(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_sub(volatile __global int *p, int val);
+OVERLOADABLE int atomic_sub(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_and(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_and(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_and(volatile __global int *p, int val);
+OVERLOADABLE int atomic_and(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_or(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_or(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_or(volatile __global int *p, int val);
+OVERLOADABLE int atomic_or(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_xor(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_xor(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_xor(volatile __global int *p, int val);
+OVERLOADABLE int atomic_xor(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_xchg(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_xchg(volatile __local uint *p, uint val);
+OVERLOADABLE int atomic_xchg(volatile __global int *p, int val);
+OVERLOADABLE int atomic_xchg(volatile __local int *p, int val);
+
+OVERLOADABLE int atomic_min(volatile __global int *p, int val);
+OVERLOADABLE int atomic_min(volatile __local int *p, int val);
+
+OVERLOADABLE int atomic_max(volatile __global int *p, int val);
+OVERLOADABLE int atomic_max(volatile __local int *p, int val);
+
+OVERLOADABLE uint atomic_min(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_min(volatile __local uint *p, uint val);
+
+OVERLOADABLE uint atomic_max(volatile __global uint *p, uint val);
+OVERLOADABLE uint atomic_max(volatile __local uint *p, uint val);
+
+OVERLOADABLE float atomic_xchg (volatile __global float *p, float val);
+OVERLOADABLE float atomic_xchg (volatile __local float *p, float val);
+
+OVERLOADABLE uint atomic_inc (volatile __global uint *p);
+OVERLOADABLE uint atomic_inc (volatile __local uint *p);
+OVERLOADABLE int atomic_inc (volatile __global int *p);
+OVERLOADABLE int atomic_inc (volatile __local int *p);
+
+OVERLOADABLE uint atomic_dec (volatile __global uint *p);
+OVERLOADABLE uint atomic_dec (volatile __local uint *p);
+OVERLOADABLE int atomic_dec (volatile __global int *p);
+OVERLOADABLE int atomic_dec (volatile __local int *p);
+
+OVERLOADABLE uint atomic_cmpxchg (volatile __global uint *p, uint cmp, uint val);
+OVERLOADABLE uint atomic_cmpxchg (volatile __local uint *p, uint cmp, uint val);
+OVERLOADABLE int atomic_cmpxchg (volatile __global int *p, int cmp, int val);
+OVERLOADABLE int atomic_cmpxchg (volatile __local int *p, int cmp, int val);
+
+
+// XXX for conformance test
+// The following atom_xxx api is on OpenCL spec 1.0.
+#define atom_add atomic_add
+#define atom_sub atomic_sub
+#define atom_and atomic_and
+#define atom_or atomic_or
+#define atom_xor atomic_xor
+#define atom_xchg atomic_xchg
+#define atom_min atomic_min
+#define atom_max atomic_max
+#define atom_inc atomic_inc
+#define atom_dec atomic_dec
+#define atom_cmpxchg atomic_cmpxchg
+
+//OpenCL 2.0 features
+#define ATOMIC_GEN_FUNCTIONS(ATYPE, CTYPE, POSTFIX) \
+CTYPE __gen_ocl_atomic_exchange##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope);  \
+CTYPE __gen_ocl_atomic_fetch_add##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_sub##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_or##POSTFIX(volatile ATYPE *p,  CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_xor##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_and##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_imin##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_umin##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_imax##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \
+CTYPE __gen_ocl_atomic_fetch_umax##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope);\
+CTYPE __gen_ocl_atomic_compare_exchange_strong##POSTFIX(volatile ATYPE* object, CTYPE expected, CTYPE desired, int sucess, int failure, int scope); \
+CTYPE __gen_ocl_atomic_compare_exchange_weak##POSTFIX(volatile ATYPE* object, CTYPE expected, CTYPE desired, int sucess, int failure, int scope);
+
+ATOMIC_GEN_FUNCTIONS(atomic_int, int, 32)
+#ifndef DISABLE_ATOMIC_INT64
+ATOMIC_GEN_FUNCTIONS(atomic_long, long, 64)
+#endif
+float __gen_ocl_atomic_exchangef(volatile atomic_int *p, float val, int order, int scope);
+float __gen_ocl_atomic_fetch_addf(volatile atomic_int *p, float val, int order, int scope);
+
+#undef ATOMIC_GEN_FUNCTIONS
+
+/* only used to initialize global address space */
+//#define ATOMIC_VAR_INIT(C value)
+#define ATOMIC_VAR_INIT
+#define ATOMIC_FLAG_INIT 0
+
+//store
+#define ATOMIC_FUNCTIONS(ATYPE, CTYPE, MTYPE1, MTYPE2) \
+OVERLOADABLE void atomic_init(volatile ATYPE *object, CTYPE desired);  \
+OVERLOADABLE void atomic_store(volatile ATYPE *object, CTYPE desired);  \
+OVERLOADABLE void atomic_store_explicit(volatile ATYPE *object, CTYPE desired, memory_order order);  \
+OVERLOADABLE void atomic_store_explicit(volatile ATYPE *object, CTYPE desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_load(volatile ATYPE *object);  \
+OVERLOADABLE CTYPE  atomic_load_explicit(volatile ATYPE *object, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_load_explicit(volatile ATYPE *object, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_exchange(volatile ATYPE *object, CTYPE desired);  \
+OVERLOADABLE CTYPE  atomic_exchange_explicit(volatile ATYPE *object, CTYPE desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_exchange_explicit(volatile ATYPE *object, CTYPE desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE bool atomic_compare_exchange_strong(volatile ATYPE *object, CTYPE *expected, CTYPE desired);  \
+OVERLOADABLE bool atomic_compare_exchange_strong_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure);  \
+OVERLOADABLE bool atomic_compare_exchange_strong_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure, memory_scope scope);  \
+OVERLOADABLE bool atomic_compare_exchange_weak(volatile ATYPE *object, CTYPE *expected, CTYPE desired);  \
+OVERLOADABLE bool atomic_compare_exchange_weak_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure);  \
+OVERLOADABLE bool atomic_compare_exchange_weak_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_add(volatile ATYPE *object, MTYPE1 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_add_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_add_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_sub(volatile ATYPE *object, MTYPE1 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_sub_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_sub_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_or(volatile ATYPE *object, MTYPE2 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_or_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_or_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_xor(volatile ATYPE *object, MTYPE2 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_xor_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_xor_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_and(volatile ATYPE *object, MTYPE2 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_and_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_and_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_min(volatile ATYPE *object, MTYPE2 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_min_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_min_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope);  \
+OVERLOADABLE CTYPE  atomic_fetch_max(volatile ATYPE *object, MTYPE2 desired);  \
+OVERLOADABLE CTYPE  atomic_fetch_max_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order);  \
+OVERLOADABLE CTYPE  atomic_fetch_max_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope);
+
+ATOMIC_FUNCTIONS(atomic_int, int, int, int)
+ATOMIC_FUNCTIONS(atomic_uint, uint, uint, uint)
+#ifndef DISABLE_ATOMIC_INT64
+ATOMIC_FUNCTIONS(atomic_long, long, long, long)
+ATOMIC_FUNCTIONS(atomic_ulong, ulong, ulong, ulong)
+#endif
+ATOMIC_FUNCTIONS(atomic_float, float, float, float)
+#undef ATOMIC_FUNCTIONS
+
+
+OVERLOADABLE bool atomic_flag_test_and_set(volatile atomic_flag *object);
+OVERLOADABLE bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);
+OVERLOADABLE bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
+OVERLOADABLE void atomic_flag_clear(volatile atomic_flag *object);
+OVERLOADABLE void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);
+OVERLOADABLE void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
+
+OVERLOADABLE void atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope);
+#endif  /* __OCL_ATOM20_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_common.h b/drivers/pocl-gen7/lib/beignet/include/ocl_common.h
new file mode 100644
index 0000000..f37067f
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_common.h
@@ -0,0 +1,370 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_COMMON_H__
+#define __OCL_COMMON_H__
+
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Common Functions
+/////////////////////////////////////////////////////////////////////////////
+OVERLOADABLE float step(float edge, float x);
+OVERLOADABLE float max(float a, float b);
+OVERLOADABLE float min(float a, float b);
+OVERLOADABLE float mix(float x, float y, float a);
+OVERLOADABLE float clamp(float v, float l, float u);
+
+OVERLOADABLE float degrees(float radians);
+OVERLOADABLE float radians(float degrees);
+OVERLOADABLE float smoothstep(float e0, float e1, float x);
+
+OVERLOADABLE float sign(float x);
+
+// Half half version.
+OVERLOADABLE half step(half edge, half x);
+OVERLOADABLE half max(half a, half b);
+OVERLOADABLE half min(half a, half b);
+OVERLOADABLE half mix(half x, half y, half a);
+OVERLOADABLE half clamp(half v, half l, half u);
+
+OVERLOADABLE half degrees(half radians);
+OVERLOADABLE half radians(half degrees);
+OVERLOADABLE half smoothstep(half e0, half e1, half x);
+
+OVERLOADABLE half sign(half x);
+
+OVERLOADABLE double step(double edge, double x);
+OVERLOADABLE double max(double a, double b);
+OVERLOADABLE double min(double a, double b);
+OVERLOADABLE double mix(double x, double y, double a);
+OVERLOADABLE double clamp(double v, double l, double u);
+OVERLOADABLE double degrees(double radians);
+OVERLOADABLE double radians(double degrees);
+OVERLOADABLE double smoothstep(double e0, double e1, double x);
+OVERLOADABLE double sign(double x);
+
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//common builtin functions
+//gentype clamp (gentype x, gentype minval, gentype maxval)
+
+OVERLOADABLE float2 clamp (float2 param0, float2 param1, float2 param2);
+OVERLOADABLE float3 clamp (float3 param0, float3 param1, float3 param2);
+OVERLOADABLE float4 clamp (float4 param0, float4 param1, float4 param2);
+OVERLOADABLE float8 clamp (float8 param0, float8 param1, float8 param2);
+OVERLOADABLE float16 clamp (float16 param0, float16 param1, float16 param2);
+OVERLOADABLE double2 clamp (double2 param0, double2 param1, double2 param2);
+OVERLOADABLE double3 clamp (double3 param0, double3 param1, double3 param2);
+OVERLOADABLE double4 clamp (double4 param0, double4 param1, double4 param2);
+OVERLOADABLE double8 clamp (double8 param0, double8 param1, double8 param2);
+OVERLOADABLE double16 clamp (double16 param0, double16 param1, double16 param2);
+OVERLOADABLE half2 clamp (half2 param0, half2 param1, half2 param2);
+OVERLOADABLE half3 clamp (half3 param0, half3 param1, half3 param2);
+OVERLOADABLE half4 clamp (half4 param0, half4 param1, half4 param2);
+OVERLOADABLE half8 clamp (half8 param0, half8 param1, half8 param2);
+OVERLOADABLE half16 clamp (half16 param0, half16 param1, half16 param2);
+
+//gentypef clamp (gentypef x, float minval, float maxval)
+
+OVERLOADABLE float2 clamp (float2 param0, float param1, float param2);
+OVERLOADABLE float3 clamp (float3 param0, float param1, float param2);
+OVERLOADABLE float4 clamp (float4 param0, float param1, float param2);
+OVERLOADABLE float8 clamp (float8 param0, float param1, float param2);
+OVERLOADABLE float16 clamp (float16 param0, float param1, float param2);
+
+//gentypeh clamp (gentypeh x, half minval, half maxval)
+
+OVERLOADABLE half2 clamp (half2 param0, half param1, half param2);
+OVERLOADABLE half3 clamp (half3 param0, half param1, half param2);
+OVERLOADABLE half4 clamp (half4 param0, half param1, half param2);
+OVERLOADABLE half8 clamp (half8 param0, half param1, half param2);
+OVERLOADABLE half16 clamp (half16 param0, half param1, half param2);
+
+//gentyped clamp (gentyped x, double minval, double maxval)
+
+OVERLOADABLE double2 clamp (double2 param0, double param1, double param2);
+OVERLOADABLE double3 clamp (double3 param0, double param1, double param2);
+OVERLOADABLE double4 clamp (double4 param0, double param1, double param2);
+OVERLOADABLE double8 clamp (double8 param0, double param1, double param2);
+OVERLOADABLE double16 clamp (double16 param0, double param1, double param2);
+
+//gentype degrees (gentype radians)
+
+OVERLOADABLE float2 degrees (float2 param0);
+OVERLOADABLE float3 degrees (float3 param0);
+OVERLOADABLE float4 degrees (float4 param0);
+OVERLOADABLE float8 degrees (float8 param0);
+OVERLOADABLE float16 degrees (float16 param0);
+OVERLOADABLE double2 degrees (double2 param0);
+OVERLOADABLE double3 degrees (double3 param0);
+OVERLOADABLE double4 degrees (double4 param0);
+OVERLOADABLE double8 degrees (double8 param0);
+OVERLOADABLE double16 degrees (double16 param0);
+OVERLOADABLE half2 degrees (half2 param0);
+OVERLOADABLE half3 degrees (half3 param0);
+OVERLOADABLE half4 degrees (half4 param0);
+OVERLOADABLE half8 degrees (half8 param0);
+OVERLOADABLE half16 degrees (half16 param0);
+
+//gentype max (gentype x,  gentype y)
+
+OVERLOADABLE float2 max (float2 param0, float2 param1);
+OVERLOADABLE float3 max (float3 param0, float3 param1);
+OVERLOADABLE float4 max (float4 param0, float4 param1);
+OVERLOADABLE float8 max (float8 param0, float8 param1);
+OVERLOADABLE float16 max (float16 param0, float16 param1);
+OVERLOADABLE double2 max (double2 param0, double2 param1);
+OVERLOADABLE double3 max (double3 param0, double3 param1);
+OVERLOADABLE double4 max (double4 param0, double4 param1);
+OVERLOADABLE double8 max (double8 param0, double8 param1);
+OVERLOADABLE double16 max (double16 param0, double16 param1);
+OVERLOADABLE half2 max (half2 param0, half2 param1);
+OVERLOADABLE half3 max (half3 param0, half3 param1);
+OVERLOADABLE half4 max (half4 param0, half4 param1);
+OVERLOADABLE half8 max (half8 param0, half8 param1);
+OVERLOADABLE half16 max (half16 param0, half16 param1);
+
+//gentypef max (gentypef x, float y)
+
+OVERLOADABLE float2 max (float2 param0, float param1);
+OVERLOADABLE float3 max (float3 param0, float param1);
+OVERLOADABLE float4 max (float4 param0, float param1);
+OVERLOADABLE float8 max (float8 param0, float param1);
+OVERLOADABLE float16 max (float16 param0, float param1);
+
+//gentypeh max (gentypeh x, half y)
+
+OVERLOADABLE half2 max (half2 param0, half param1);
+OVERLOADABLE half3 max (half3 param0, half param1);
+OVERLOADABLE half4 max (half4 param0, half param1);
+OVERLOADABLE half8 max (half8 param0, half param1);
+OVERLOADABLE half16 max (half16 param0, half param1);
+
+//gentyped max (gentyped x, double y)
+
+OVERLOADABLE double2 max (double2 param0, double param1);
+OVERLOADABLE double3 max (double3 param0, double param1);
+OVERLOADABLE double4 max (double4 param0, double param1);
+OVERLOADABLE double8 max (double8 param0, double param1);
+OVERLOADABLE double16 max (double16 param0, double param1);
+
+//gentype min (gentype x,  gentype y)
+
+OVERLOADABLE float2 min (float2 param0, float2 param1);
+OVERLOADABLE float3 min (float3 param0, float3 param1);
+OVERLOADABLE float4 min (float4 param0, float4 param1);
+OVERLOADABLE float8 min (float8 param0, float8 param1);
+OVERLOADABLE float16 min (float16 param0, float16 param1);
+OVERLOADABLE double2 min (double2 param0, double2 param1);
+OVERLOADABLE double3 min (double3 param0, double3 param1);
+OVERLOADABLE double4 min (double4 param0, double4 param1);
+OVERLOADABLE double8 min (double8 param0, double8 param1);
+OVERLOADABLE double16 min (double16 param0, double16 param1);
+OVERLOADABLE half2 min (half2 param0, half2 param1);
+OVERLOADABLE half3 min (half3 param0, half3 param1);
+OVERLOADABLE half4 min (half4 param0, half4 param1);
+OVERLOADABLE half8 min (half8 param0, half8 param1);
+OVERLOADABLE half16 min (half16 param0, half16 param1);
+
+//gentypef min (gentypef x,  float y)
+
+OVERLOADABLE float2 min (float2 param0, float param1);
+OVERLOADABLE float3 min (float3 param0, float param1);
+OVERLOADABLE float4 min (float4 param0, float param1);
+OVERLOADABLE float8 min (float8 param0, float param1);
+OVERLOADABLE float16 min (float16 param0, float param1);
+
+//gentypeh min (gentypeh x,  half y)
+
+OVERLOADABLE half2 min (half2 param0, half param1);
+OVERLOADABLE half3 min (half3 param0, half param1);
+OVERLOADABLE half4 min (half4 param0, half param1);
+OVERLOADABLE half8 min (half8 param0, half param1);
+OVERLOADABLE half16 min (half16 param0, half param1);
+
+//gentyped min (gentyped x,  double y)
+
+OVERLOADABLE double2 min (double2 param0, double param1);
+OVERLOADABLE double3 min (double3 param0, double param1);
+OVERLOADABLE double4 min (double4 param0, double param1);
+OVERLOADABLE double8 min (double8 param0, double param1);
+OVERLOADABLE double16 min (double16 param0, double param1);
+
+//gentype mix (gentype x, gentype y, gentype a)
+
+OVERLOADABLE float2 mix (float2 param0, float2 param1, float2 param2);
+OVERLOADABLE float3 mix (float3 param0, float3 param1, float3 param2);
+OVERLOADABLE float4 mix (float4 param0, float4 param1, float4 param2);
+OVERLOADABLE float8 mix (float8 param0, float8 param1, float8 param2);
+OVERLOADABLE float16 mix (float16 param0, float16 param1, float16 param2);
+OVERLOADABLE double2 mix (double2 param0, double2 param1, double2 param2);
+OVERLOADABLE double3 mix (double3 param0, double3 param1, double3 param2);
+OVERLOADABLE double4 mix (double4 param0, double4 param1, double4 param2);
+OVERLOADABLE double8 mix (double8 param0, double8 param1, double8 param2);
+OVERLOADABLE double16 mix (double16 param0, double16 param1, double16 param2);
+OVERLOADABLE half2 mix (half2 param0, half2 param1, half2 param2);
+OVERLOADABLE half3 mix (half3 param0, half3 param1, half3 param2);
+OVERLOADABLE half4 mix (half4 param0, half4 param1, half4 param2);
+OVERLOADABLE half8 mix (half8 param0, half8 param1, half8 param2);
+OVERLOADABLE half16 mix (half16 param0, half16 param1, half16 param2);
+
+//gentypef mix (gentypef x, gentypef y, float a)
+
+OVERLOADABLE float2 mix (float2 param0, float2 param1, float param2);
+OVERLOADABLE float3 mix (float3 param0, float3 param1, float param2);
+OVERLOADABLE float4 mix (float4 param0, float4 param1, float param2);
+OVERLOADABLE float8 mix (float8 param0, float8 param1, float param2);
+OVERLOADABLE float16 mix (float16 param0, float16 param1, float param2);
+
+//gentypeh mix (gentypeh x, gentypeh y, half a)
+
+OVERLOADABLE half2 mix (half2 param0, half2 param1, half param2);
+OVERLOADABLE half3 mix (half3 param0, half3 param1, half param2);
+OVERLOADABLE half4 mix (half4 param0, half4 param1, half param2);
+OVERLOADABLE half8 mix (half8 param0, half8 param1, half param2);
+OVERLOADABLE half16 mix (half16 param0, half16 param1, half param2);
+
+//gentyped mix (gentyped x, gentyped y, double a)
+
+OVERLOADABLE double2 mix (double2 param0, double2 param1, double param2);
+OVERLOADABLE double3 mix (double3 param0, double3 param1, double param2);
+OVERLOADABLE double4 mix (double4 param0, double4 param1, double param2);
+OVERLOADABLE double8 mix (double8 param0, double8 param1, double param2);
+OVERLOADABLE double16 mix (double16 param0, double16 param1, double param2);
+
+//gentype radians (gentype degrees)
+
+OVERLOADABLE float2 radians (float2 param0);
+OVERLOADABLE float3 radians (float3 param0);
+OVERLOADABLE float4 radians (float4 param0);
+OVERLOADABLE float8 radians (float8 param0);
+OVERLOADABLE float16 radians (float16 param0);
+OVERLOADABLE double2 radians (double2 param0);
+OVERLOADABLE double3 radians (double3 param0);
+OVERLOADABLE double4 radians (double4 param0);
+OVERLOADABLE double8 radians (double8 param0);
+OVERLOADABLE double16 radians (double16 param0);
+OVERLOADABLE half2 radians (half2 param0);
+OVERLOADABLE half3 radians (half3 param0);
+OVERLOADABLE half4 radians (half4 param0);
+OVERLOADABLE half8 radians (half8 param0);
+OVERLOADABLE half16 radians (half16 param0);
+
+//gentype step (gentype edge, gentype x)
+
+OVERLOADABLE float2 step (float2 param0, float2 param1);
+OVERLOADABLE float3 step (float3 param0, float3 param1);
+OVERLOADABLE float4 step (float4 param0, float4 param1);
+OVERLOADABLE float8 step (float8 param0, float8 param1);
+OVERLOADABLE float16 step (float16 param0, float16 param1);
+OVERLOADABLE double2 step (double2 param0, double2 param1);
+OVERLOADABLE double3 step (double3 param0, double3 param1);
+OVERLOADABLE double4 step (double4 param0, double4 param1);
+OVERLOADABLE double8 step (double8 param0, double8 param1);
+OVERLOADABLE double16 step (double16 param0, double16 param1);
+OVERLOADABLE half2 step (half2 param0, half2 param1);
+OVERLOADABLE half3 step (half3 param0, half3 param1);
+OVERLOADABLE half4 step (half4 param0, half4 param1);
+OVERLOADABLE half8 step (half8 param0, half8 param1);
+OVERLOADABLE half16 step (half16 param0, half16 param1);
+
+//gentypef step (float edge, gentypef x)
+
+OVERLOADABLE float2 step (float param0, float2 param1);
+OVERLOADABLE float3 step (float param0, float3 param1);
+OVERLOADABLE float4 step (float param0, float4 param1);
+OVERLOADABLE float8 step (float param0, float8 param1);
+OVERLOADABLE float16 step (float param0, float16 param1);
+
+//gentypeh step (half edge, gentypeh x)
+
+OVERLOADABLE half2 step (half param0, half2 param1);
+OVERLOADABLE half3 step (half param0, half3 param1);
+OVERLOADABLE half4 step (half param0, half4 param1);
+OVERLOADABLE half8 step (half param0, half8 param1);
+OVERLOADABLE half16 step (half param0, half16 param1);
+
+//gentyped step (double edge, gentyped x)
+
+OVERLOADABLE double2 step (double param0, double2 param1);
+OVERLOADABLE double3 step (double param0, double3 param1);
+OVERLOADABLE double4 step (double param0, double4 param1);
+OVERLOADABLE double8 step (double param0, double8 param1);
+OVERLOADABLE double16 step (double param0, double16 param1);
+
+//gentype smoothstep (gentype edge0, gentype edge1, gentype x)
+
+OVERLOADABLE float2 smoothstep (float2 param0, float2 param1, float2 param2);
+OVERLOADABLE float3 smoothstep (float3 param0, float3 param1, float3 param2);
+OVERLOADABLE float4 smoothstep (float4 param0, float4 param1, float4 param2);
+OVERLOADABLE float8 smoothstep (float8 param0, float8 param1, float8 param2);
+OVERLOADABLE float16 smoothstep (float16 param0, float16 param1, float16 param2);
+OVERLOADABLE double2 smoothstep (double2 param0, double2 param1, double2 param2);
+OVERLOADABLE double3 smoothstep (double3 param0, double3 param1, double3 param2);
+OVERLOADABLE double4 smoothstep (double4 param0, double4 param1, double4 param2);
+OVERLOADABLE double8 smoothstep (double8 param0, double8 param1, double8 param2);
+OVERLOADABLE double16 smoothstep (double16 param0, double16 param1, double16 param2);
+OVERLOADABLE half2 smoothstep (half2 param0, half2 param1, half2 param2);
+OVERLOADABLE half3 smoothstep (half3 param0, half3 param1, half3 param2);
+OVERLOADABLE half4 smoothstep (half4 param0, half4 param1, half4 param2);
+OVERLOADABLE half8 smoothstep (half8 param0, half8 param1, half8 param2);
+OVERLOADABLE half16 smoothstep (half16 param0, half16 param1, half16 param2);
+
+//gentypef smoothstep (float edge0, float edge1, gentypef x)
+
+OVERLOADABLE float2 smoothstep (float param0, float param1, float2 param2);
+OVERLOADABLE float3 smoothstep (float param0, float param1, float3 param2);
+OVERLOADABLE float4 smoothstep (float param0, float param1, float4 param2);
+OVERLOADABLE float8 smoothstep (float param0, float param1, float8 param2);
+OVERLOADABLE float16 smoothstep (float param0, float param1, float16 param2);
+
+//gentypeh smoothstep (half edge0, half edge1, gentypeh x)
+
+OVERLOADABLE half2 smoothstep (half param0, half param1, half2 param2);
+OVERLOADABLE half3 smoothstep (half param0, half param1, half3 param2);
+OVERLOADABLE half4 smoothstep (half param0, half param1, half4 param2);
+OVERLOADABLE half8 smoothstep (half param0, half param1, half8 param2);
+OVERLOADABLE half16 smoothstep (half param0, half param1, half16 param2);
+
+//gentyped smoothstep (double edge0, double edge1, gentyped x)
+
+OVERLOADABLE double2 smoothstep (double param0, double param1, double2 param2);
+OVERLOADABLE double3 smoothstep (double param0, double param1, double3 param2);
+OVERLOADABLE double4 smoothstep (double param0, double param1, double4 param2);
+OVERLOADABLE double8 smoothstep (double param0, double param1, double8 param2);
+OVERLOADABLE double16 smoothstep (double param0, double param1, double16 param2);
+
+//gentype sign (gentype x)
+
+OVERLOADABLE float2 sign (float2 param0);
+OVERLOADABLE float3 sign (float3 param0);
+OVERLOADABLE float4 sign (float4 param0);
+OVERLOADABLE float8 sign (float8 param0);
+OVERLOADABLE float16 sign (float16 param0);
+OVERLOADABLE double2 sign (double2 param0);
+OVERLOADABLE double3 sign (double3 param0);
+OVERLOADABLE double4 sign (double4 param0);
+OVERLOADABLE double8 sign (double8 param0);
+OVERLOADABLE double16 sign (double16 param0);
+OVERLOADABLE half2 sign (half2 param0);
+OVERLOADABLE half3 sign (half3 param0);
+OVERLOADABLE half4 sign (half4 param0);
+OVERLOADABLE half8 sign (half8 param0);
+OVERLOADABLE half16 sign (half16 param0);
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_convert.h b/drivers/pocl-gen7/lib/beignet/include/ocl_convert.h
new file mode 100644
index 0000000..bc04529
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_convert.h
@@ -0,0 +1,6279 @@
+
+/*
+ * Copyright © 2012 - 2014 Intel Corporatio
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __OCL_CONVERT_H__
+#define __OCL_CONVERT_H__
+#include "ocl_types.h"
+
+OVERLOADABLE long convert_long(long v);
+OVERLOADABLE ulong convert_ulong(long v);
+OVERLOADABLE int convert_int(long v);
+OVERLOADABLE uint convert_uint(long v);
+OVERLOADABLE short convert_short(long v);
+OVERLOADABLE ushort convert_ushort(long v);
+OVERLOADABLE char convert_char(long v);
+OVERLOADABLE uchar convert_uchar(long v);
+OVERLOADABLE double convert_double(long v);
+OVERLOADABLE float convert_float(long v);
+OVERLOADABLE half convert_half(long v);
+OVERLOADABLE long convert_long(ulong v);
+OVERLOADABLE ulong convert_ulong(ulong v);
+OVERLOADABLE int convert_int(ulong v);
+OVERLOADABLE uint convert_uint(ulong v);
+OVERLOADABLE short convert_short(ulong v);
+OVERLOADABLE ushort convert_ushort(ulong v);
+OVERLOADABLE char convert_char(ulong v);
+OVERLOADABLE uchar convert_uchar(ulong v);
+OVERLOADABLE double convert_double(ulong v);
+OVERLOADABLE float convert_float(ulong v);
+OVERLOADABLE half convert_half(ulong v);
+OVERLOADABLE long convert_long(int v);
+OVERLOADABLE ulong convert_ulong(int v);
+OVERLOADABLE int convert_int(int v);
+OVERLOADABLE uint convert_uint(int v);
+OVERLOADABLE short convert_short(int v);
+OVERLOADABLE ushort convert_ushort(int v);
+OVERLOADABLE char convert_char(int v);
+OVERLOADABLE uchar convert_uchar(int v);
+OVERLOADABLE double convert_double(int v);
+OVERLOADABLE float convert_float(int v);
+OVERLOADABLE half convert_half(int v);
+OVERLOADABLE long convert_long(uint v);
+OVERLOADABLE ulong convert_ulong(uint v);
+OVERLOADABLE int convert_int(uint v);
+OVERLOADABLE uint convert_uint(uint v);
+OVERLOADABLE short convert_short(uint v);
+OVERLOADABLE ushort convert_ushort(uint v);
+OVERLOADABLE char convert_char(uint v);
+OVERLOADABLE uchar convert_uchar(uint v);
+OVERLOADABLE double convert_double(uint v);
+OVERLOADABLE float convert_float(uint v);
+OVERLOADABLE half convert_half(uint v);
+OVERLOADABLE long convert_long(short v);
+OVERLOADABLE ulong convert_ulong(short v);
+OVERLOADABLE int convert_int(short v);
+OVERLOADABLE uint convert_uint(short v);
+OVERLOADABLE short convert_short(short v);
+OVERLOADABLE ushort convert_ushort(short v);
+OVERLOADABLE char convert_char(short v);
+OVERLOADABLE uchar convert_uchar(short v);
+OVERLOADABLE double convert_double(short v);
+OVERLOADABLE float convert_float(short v);
+OVERLOADABLE half convert_half(short v);
+OVERLOADABLE long convert_long(ushort v);
+OVERLOADABLE ulong convert_ulong(ushort v);
+OVERLOADABLE int convert_int(ushort v);
+OVERLOADABLE uint convert_uint(ushort v);
+OVERLOADABLE short convert_short(ushort v);
+OVERLOADABLE ushort convert_ushort(ushort v);
+OVERLOADABLE char convert_char(ushort v);
+OVERLOADABLE uchar convert_uchar(ushort v);
+OVERLOADABLE double convert_double(ushort v);
+OVERLOADABLE float convert_float(ushort v);
+OVERLOADABLE half convert_half(ushort v);
+OVERLOADABLE long convert_long(char v);
+OVERLOADABLE ulong convert_ulong(char v);
+OVERLOADABLE int convert_int(char v);
+OVERLOADABLE uint convert_uint(char v);
+OVERLOADABLE short convert_short(char v);
+OVERLOADABLE ushort convert_ushort(char v);
+OVERLOADABLE char convert_char(char v);
+OVERLOADABLE uchar convert_uchar(char v);
+OVERLOADABLE double convert_double(char v);
+OVERLOADABLE float convert_float(char v);
+OVERLOADABLE half convert_half(char v);
+OVERLOADABLE long convert_long(uchar v);
+OVERLOADABLE ulong convert_ulong(uchar v);
+OVERLOADABLE int convert_int(uchar v);
+OVERLOADABLE uint convert_uint(uchar v);
+OVERLOADABLE short convert_short(uchar v);
+OVERLOADABLE ushort convert_ushort(uchar v);
+OVERLOADABLE char convert_char(uchar v);
+OVERLOADABLE uchar convert_uchar(uchar v);
+OVERLOADABLE double convert_double(uchar v);
+OVERLOADABLE float convert_float(uchar v);
+OVERLOADABLE half convert_half(uchar v);
+OVERLOADABLE long convert_long(double v);
+OVERLOADABLE ulong convert_ulong(double v);
+OVERLOADABLE int convert_int(double v);
+OVERLOADABLE uint convert_uint(double v);
+OVERLOADABLE short convert_short(double v);
+OVERLOADABLE ushort convert_ushort(double v);
+OVERLOADABLE char convert_char(double v);
+OVERLOADABLE uchar convert_uchar(double v);
+OVERLOADABLE double convert_double(double v);
+OVERLOADABLE float convert_float(double v);
+OVERLOADABLE half convert_half(double v);
+OVERLOADABLE long convert_long(float v);
+OVERLOADABLE ulong convert_ulong(float v);
+OVERLOADABLE int convert_int(float v);
+OVERLOADABLE uint convert_uint(float v);
+OVERLOADABLE short convert_short(float v);
+OVERLOADABLE ushort convert_ushort(float v);
+OVERLOADABLE char convert_char(float v);
+OVERLOADABLE uchar convert_uchar(float v);
+OVERLOADABLE double convert_double(float v);
+OVERLOADABLE float convert_float(float v);
+OVERLOADABLE half convert_half(float v);
+OVERLOADABLE long convert_long(half v);
+OVERLOADABLE ulong convert_ulong(half v);
+OVERLOADABLE int convert_int(half v);
+OVERLOADABLE uint convert_uint(half v);
+OVERLOADABLE short convert_short(half v);
+OVERLOADABLE ushort convert_ushort(half v);
+OVERLOADABLE char convert_char(half v);
+OVERLOADABLE uchar convert_uchar(half v);
+OVERLOADABLE double convert_double(half v);
+OVERLOADABLE float convert_float(half v);
+OVERLOADABLE half convert_half(half v);
+OVERLOADABLE long2 convert_long2(long2 v);
+OVERLOADABLE ulong2 convert_ulong2(long2 v);
+OVERLOADABLE int2 convert_int2(long2 v);
+OVERLOADABLE uint2 convert_uint2(long2 v);
+OVERLOADABLE short2 convert_short2(long2 v);
+OVERLOADABLE ushort2 convert_ushort2(long2 v);
+OVERLOADABLE char2 convert_char2(long2 v);
+OVERLOADABLE uchar2 convert_uchar2(long2 v);
+OVERLOADABLE double2 convert_double2(long2 v);
+OVERLOADABLE float2 convert_float2(long2 v);
+OVERLOADABLE half2 convert_half2(long2 v);
+OVERLOADABLE long2 convert_long2(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2(ulong2 v);
+OVERLOADABLE int2 convert_int2(ulong2 v);
+OVERLOADABLE uint2 convert_uint2(ulong2 v);
+OVERLOADABLE short2 convert_short2(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2(ulong2 v);
+OVERLOADABLE char2 convert_char2(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2(ulong2 v);
+OVERLOADABLE double2 convert_double2(ulong2 v);
+OVERLOADABLE float2 convert_float2(ulong2 v);
+OVERLOADABLE half2 convert_half2(ulong2 v);
+OVERLOADABLE long2 convert_long2(int2 v);
+OVERLOADABLE ulong2 convert_ulong2(int2 v);
+OVERLOADABLE int2 convert_int2(int2 v);
+OVERLOADABLE uint2 convert_uint2(int2 v);
+OVERLOADABLE short2 convert_short2(int2 v);
+OVERLOADABLE ushort2 convert_ushort2(int2 v);
+OVERLOADABLE char2 convert_char2(int2 v);
+OVERLOADABLE uchar2 convert_uchar2(int2 v);
+OVERLOADABLE double2 convert_double2(int2 v);
+OVERLOADABLE float2 convert_float2(int2 v);
+OVERLOADABLE half2 convert_half2(int2 v);
+OVERLOADABLE long2 convert_long2(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2(uint2 v);
+OVERLOADABLE int2 convert_int2(uint2 v);
+OVERLOADABLE uint2 convert_uint2(uint2 v);
+OVERLOADABLE short2 convert_short2(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2(uint2 v);
+OVERLOADABLE char2 convert_char2(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2(uint2 v);
+OVERLOADABLE double2 convert_double2(uint2 v);
+OVERLOADABLE float2 convert_float2(uint2 v);
+OVERLOADABLE half2 convert_half2(uint2 v);
+OVERLOADABLE long2 convert_long2(short2 v);
+OVERLOADABLE ulong2 convert_ulong2(short2 v);
+OVERLOADABLE int2 convert_int2(short2 v);
+OVERLOADABLE uint2 convert_uint2(short2 v);
+OVERLOADABLE short2 convert_short2(short2 v);
+OVERLOADABLE ushort2 convert_ushort2(short2 v);
+OVERLOADABLE char2 convert_char2(short2 v);
+OVERLOADABLE uchar2 convert_uchar2(short2 v);
+OVERLOADABLE double2 convert_double2(short2 v);
+OVERLOADABLE float2 convert_float2(short2 v);
+OVERLOADABLE half2 convert_half2(short2 v);
+OVERLOADABLE long2 convert_long2(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2(ushort2 v);
+OVERLOADABLE int2 convert_int2(ushort2 v);
+OVERLOADABLE uint2 convert_uint2(ushort2 v);
+OVERLOADABLE short2 convert_short2(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2(ushort2 v);
+OVERLOADABLE char2 convert_char2(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2(ushort2 v);
+OVERLOADABLE double2 convert_double2(ushort2 v);
+OVERLOADABLE float2 convert_float2(ushort2 v);
+OVERLOADABLE half2 convert_half2(ushort2 v);
+OVERLOADABLE long2 convert_long2(char2 v);
+OVERLOADABLE ulong2 convert_ulong2(char2 v);
+OVERLOADABLE int2 convert_int2(char2 v);
+OVERLOADABLE uint2 convert_uint2(char2 v);
+OVERLOADABLE short2 convert_short2(char2 v);
+OVERLOADABLE ushort2 convert_ushort2(char2 v);
+OVERLOADABLE char2 convert_char2(char2 v);
+OVERLOADABLE uchar2 convert_uchar2(char2 v);
+OVERLOADABLE double2 convert_double2(char2 v);
+OVERLOADABLE float2 convert_float2(char2 v);
+OVERLOADABLE half2 convert_half2(char2 v);
+OVERLOADABLE long2 convert_long2(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2(uchar2 v);
+OVERLOADABLE int2 convert_int2(uchar2 v);
+OVERLOADABLE uint2 convert_uint2(uchar2 v);
+OVERLOADABLE short2 convert_short2(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2(uchar2 v);
+OVERLOADABLE char2 convert_char2(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2(uchar2 v);
+OVERLOADABLE double2 convert_double2(uchar2 v);
+OVERLOADABLE float2 convert_float2(uchar2 v);
+OVERLOADABLE half2 convert_half2(uchar2 v);
+OVERLOADABLE long2 convert_long2(double2 v);
+OVERLOADABLE ulong2 convert_ulong2(double2 v);
+OVERLOADABLE int2 convert_int2(double2 v);
+OVERLOADABLE uint2 convert_uint2(double2 v);
+OVERLOADABLE short2 convert_short2(double2 v);
+OVERLOADABLE ushort2 convert_ushort2(double2 v);
+OVERLOADABLE char2 convert_char2(double2 v);
+OVERLOADABLE uchar2 convert_uchar2(double2 v);
+OVERLOADABLE double2 convert_double2(double2 v);
+OVERLOADABLE float2 convert_float2(double2 v);
+OVERLOADABLE half2 convert_half2(double2 v);
+OVERLOADABLE long2 convert_long2(float2 v);
+OVERLOADABLE ulong2 convert_ulong2(float2 v);
+OVERLOADABLE int2 convert_int2(float2 v);
+OVERLOADABLE uint2 convert_uint2(float2 v);
+OVERLOADABLE short2 convert_short2(float2 v);
+OVERLOADABLE ushort2 convert_ushort2(float2 v);
+OVERLOADABLE char2 convert_char2(float2 v);
+OVERLOADABLE uchar2 convert_uchar2(float2 v);
+OVERLOADABLE double2 convert_double2(float2 v);
+OVERLOADABLE float2 convert_float2(float2 v);
+OVERLOADABLE half2 convert_half2(float2 v);
+OVERLOADABLE long2 convert_long2(half2 v);
+OVERLOADABLE ulong2 convert_ulong2(half2 v);
+OVERLOADABLE int2 convert_int2(half2 v);
+OVERLOADABLE uint2 convert_uint2(half2 v);
+OVERLOADABLE short2 convert_short2(half2 v);
+OVERLOADABLE ushort2 convert_ushort2(half2 v);
+OVERLOADABLE char2 convert_char2(half2 v);
+OVERLOADABLE uchar2 convert_uchar2(half2 v);
+OVERLOADABLE double2 convert_double2(half2 v);
+OVERLOADABLE float2 convert_float2(half2 v);
+OVERLOADABLE half2 convert_half2(half2 v);
+OVERLOADABLE long3 convert_long3(long3 v);
+OVERLOADABLE ulong3 convert_ulong3(long3 v);
+OVERLOADABLE int3 convert_int3(long3 v);
+OVERLOADABLE uint3 convert_uint3(long3 v);
+OVERLOADABLE short3 convert_short3(long3 v);
+OVERLOADABLE ushort3 convert_ushort3(long3 v);
+OVERLOADABLE char3 convert_char3(long3 v);
+OVERLOADABLE uchar3 convert_uchar3(long3 v);
+OVERLOADABLE double3 convert_double3(long3 v);
+OVERLOADABLE float3 convert_float3(long3 v);
+OVERLOADABLE half3 convert_half3(long3 v);
+OVERLOADABLE long3 convert_long3(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3(ulong3 v);
+OVERLOADABLE int3 convert_int3(ulong3 v);
+OVERLOADABLE uint3 convert_uint3(ulong3 v);
+OVERLOADABLE short3 convert_short3(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3(ulong3 v);
+OVERLOADABLE char3 convert_char3(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3(ulong3 v);
+OVERLOADABLE double3 convert_double3(ulong3 v);
+OVERLOADABLE float3 convert_float3(ulong3 v);
+OVERLOADABLE half3 convert_half3(ulong3 v);
+OVERLOADABLE long3 convert_long3(int3 v);
+OVERLOADABLE ulong3 convert_ulong3(int3 v);
+OVERLOADABLE int3 convert_int3(int3 v);
+OVERLOADABLE uint3 convert_uint3(int3 v);
+OVERLOADABLE short3 convert_short3(int3 v);
+OVERLOADABLE ushort3 convert_ushort3(int3 v);
+OVERLOADABLE char3 convert_char3(int3 v);
+OVERLOADABLE uchar3 convert_uchar3(int3 v);
+OVERLOADABLE double3 convert_double3(int3 v);
+OVERLOADABLE float3 convert_float3(int3 v);
+OVERLOADABLE half3 convert_half3(int3 v);
+OVERLOADABLE long3 convert_long3(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3(uint3 v);
+OVERLOADABLE int3 convert_int3(uint3 v);
+OVERLOADABLE uint3 convert_uint3(uint3 v);
+OVERLOADABLE short3 convert_short3(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3(uint3 v);
+OVERLOADABLE char3 convert_char3(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3(uint3 v);
+OVERLOADABLE double3 convert_double3(uint3 v);
+OVERLOADABLE float3 convert_float3(uint3 v);
+OVERLOADABLE half3 convert_half3(uint3 v);
+OVERLOADABLE long3 convert_long3(short3 v);
+OVERLOADABLE ulong3 convert_ulong3(short3 v);
+OVERLOADABLE int3 convert_int3(short3 v);
+OVERLOADABLE uint3 convert_uint3(short3 v);
+OVERLOADABLE short3 convert_short3(short3 v);
+OVERLOADABLE ushort3 convert_ushort3(short3 v);
+OVERLOADABLE char3 convert_char3(short3 v);
+OVERLOADABLE uchar3 convert_uchar3(short3 v);
+OVERLOADABLE double3 convert_double3(short3 v);
+OVERLOADABLE float3 convert_float3(short3 v);
+OVERLOADABLE half3 convert_half3(short3 v);
+OVERLOADABLE long3 convert_long3(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3(ushort3 v);
+OVERLOADABLE int3 convert_int3(ushort3 v);
+OVERLOADABLE uint3 convert_uint3(ushort3 v);
+OVERLOADABLE short3 convert_short3(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3(ushort3 v);
+OVERLOADABLE char3 convert_char3(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3(ushort3 v);
+OVERLOADABLE double3 convert_double3(ushort3 v);
+OVERLOADABLE float3 convert_float3(ushort3 v);
+OVERLOADABLE half3 convert_half3(ushort3 v);
+OVERLOADABLE long3 convert_long3(char3 v);
+OVERLOADABLE ulong3 convert_ulong3(char3 v);
+OVERLOADABLE int3 convert_int3(char3 v);
+OVERLOADABLE uint3 convert_uint3(char3 v);
+OVERLOADABLE short3 convert_short3(char3 v);
+OVERLOADABLE ushort3 convert_ushort3(char3 v);
+OVERLOADABLE char3 convert_char3(char3 v);
+OVERLOADABLE uchar3 convert_uchar3(char3 v);
+OVERLOADABLE double3 convert_double3(char3 v);
+OVERLOADABLE float3 convert_float3(char3 v);
+OVERLOADABLE half3 convert_half3(char3 v);
+OVERLOADABLE long3 convert_long3(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3(uchar3 v);
+OVERLOADABLE int3 convert_int3(uchar3 v);
+OVERLOADABLE uint3 convert_uint3(uchar3 v);
+OVERLOADABLE short3 convert_short3(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3(uchar3 v);
+OVERLOADABLE char3 convert_char3(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3(uchar3 v);
+OVERLOADABLE double3 convert_double3(uchar3 v);
+OVERLOADABLE float3 convert_float3(uchar3 v);
+OVERLOADABLE half3 convert_half3(uchar3 v);
+OVERLOADABLE long3 convert_long3(double3 v);
+OVERLOADABLE ulong3 convert_ulong3(double3 v);
+OVERLOADABLE int3 convert_int3(double3 v);
+OVERLOADABLE uint3 convert_uint3(double3 v);
+OVERLOADABLE short3 convert_short3(double3 v);
+OVERLOADABLE ushort3 convert_ushort3(double3 v);
+OVERLOADABLE char3 convert_char3(double3 v);
+OVERLOADABLE uchar3 convert_uchar3(double3 v);
+OVERLOADABLE double3 convert_double3(double3 v);
+OVERLOADABLE float3 convert_float3(double3 v);
+OVERLOADABLE half3 convert_half3(double3 v);
+OVERLOADABLE long3 convert_long3(float3 v);
+OVERLOADABLE ulong3 convert_ulong3(float3 v);
+OVERLOADABLE int3 convert_int3(float3 v);
+OVERLOADABLE uint3 convert_uint3(float3 v);
+OVERLOADABLE short3 convert_short3(float3 v);
+OVERLOADABLE ushort3 convert_ushort3(float3 v);
+OVERLOADABLE char3 convert_char3(float3 v);
+OVERLOADABLE uchar3 convert_uchar3(float3 v);
+OVERLOADABLE double3 convert_double3(float3 v);
+OVERLOADABLE float3 convert_float3(float3 v);
+OVERLOADABLE half3 convert_half3(float3 v);
+OVERLOADABLE long3 convert_long3(half3 v);
+OVERLOADABLE ulong3 convert_ulong3(half3 v);
+OVERLOADABLE int3 convert_int3(half3 v);
+OVERLOADABLE uint3 convert_uint3(half3 v);
+OVERLOADABLE short3 convert_short3(half3 v);
+OVERLOADABLE ushort3 convert_ushort3(half3 v);
+OVERLOADABLE char3 convert_char3(half3 v);
+OVERLOADABLE uchar3 convert_uchar3(half3 v);
+OVERLOADABLE double3 convert_double3(half3 v);
+OVERLOADABLE float3 convert_float3(half3 v);
+OVERLOADABLE half3 convert_half3(half3 v);
+OVERLOADABLE long4 convert_long4(long4 v);
+OVERLOADABLE ulong4 convert_ulong4(long4 v);
+OVERLOADABLE int4 convert_int4(long4 v);
+OVERLOADABLE uint4 convert_uint4(long4 v);
+OVERLOADABLE short4 convert_short4(long4 v);
+OVERLOADABLE ushort4 convert_ushort4(long4 v);
+OVERLOADABLE char4 convert_char4(long4 v);
+OVERLOADABLE uchar4 convert_uchar4(long4 v);
+OVERLOADABLE double4 convert_double4(long4 v);
+OVERLOADABLE float4 convert_float4(long4 v);
+OVERLOADABLE half4 convert_half4(long4 v);
+OVERLOADABLE long4 convert_long4(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4(ulong4 v);
+OVERLOADABLE int4 convert_int4(ulong4 v);
+OVERLOADABLE uint4 convert_uint4(ulong4 v);
+OVERLOADABLE short4 convert_short4(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4(ulong4 v);
+OVERLOADABLE char4 convert_char4(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4(ulong4 v);
+OVERLOADABLE double4 convert_double4(ulong4 v);
+OVERLOADABLE float4 convert_float4(ulong4 v);
+OVERLOADABLE half4 convert_half4(ulong4 v);
+OVERLOADABLE long4 convert_long4(int4 v);
+OVERLOADABLE ulong4 convert_ulong4(int4 v);
+OVERLOADABLE int4 convert_int4(int4 v);
+OVERLOADABLE uint4 convert_uint4(int4 v);
+OVERLOADABLE short4 convert_short4(int4 v);
+OVERLOADABLE ushort4 convert_ushort4(int4 v);
+OVERLOADABLE char4 convert_char4(int4 v);
+OVERLOADABLE uchar4 convert_uchar4(int4 v);
+OVERLOADABLE double4 convert_double4(int4 v);
+OVERLOADABLE float4 convert_float4(int4 v);
+OVERLOADABLE half4 convert_half4(int4 v);
+OVERLOADABLE long4 convert_long4(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4(uint4 v);
+OVERLOADABLE int4 convert_int4(uint4 v);
+OVERLOADABLE uint4 convert_uint4(uint4 v);
+OVERLOADABLE short4 convert_short4(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4(uint4 v);
+OVERLOADABLE char4 convert_char4(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4(uint4 v);
+OVERLOADABLE double4 convert_double4(uint4 v);
+OVERLOADABLE float4 convert_float4(uint4 v);
+OVERLOADABLE half4 convert_half4(uint4 v);
+OVERLOADABLE long4 convert_long4(short4 v);
+OVERLOADABLE ulong4 convert_ulong4(short4 v);
+OVERLOADABLE int4 convert_int4(short4 v);
+OVERLOADABLE uint4 convert_uint4(short4 v);
+OVERLOADABLE short4 convert_short4(short4 v);
+OVERLOADABLE ushort4 convert_ushort4(short4 v);
+OVERLOADABLE char4 convert_char4(short4 v);
+OVERLOADABLE uchar4 convert_uchar4(short4 v);
+OVERLOADABLE double4 convert_double4(short4 v);
+OVERLOADABLE float4 convert_float4(short4 v);
+OVERLOADABLE half4 convert_half4(short4 v);
+OVERLOADABLE long4 convert_long4(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4(ushort4 v);
+OVERLOADABLE int4 convert_int4(ushort4 v);
+OVERLOADABLE uint4 convert_uint4(ushort4 v);
+OVERLOADABLE short4 convert_short4(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4(ushort4 v);
+OVERLOADABLE char4 convert_char4(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4(ushort4 v);
+OVERLOADABLE double4 convert_double4(ushort4 v);
+OVERLOADABLE float4 convert_float4(ushort4 v);
+OVERLOADABLE half4 convert_half4(ushort4 v);
+OVERLOADABLE long4 convert_long4(char4 v);
+OVERLOADABLE ulong4 convert_ulong4(char4 v);
+OVERLOADABLE int4 convert_int4(char4 v);
+OVERLOADABLE uint4 convert_uint4(char4 v);
+OVERLOADABLE short4 convert_short4(char4 v);
+OVERLOADABLE ushort4 convert_ushort4(char4 v);
+OVERLOADABLE char4 convert_char4(char4 v);
+OVERLOADABLE uchar4 convert_uchar4(char4 v);
+OVERLOADABLE double4 convert_double4(char4 v);
+OVERLOADABLE float4 convert_float4(char4 v);
+OVERLOADABLE half4 convert_half4(char4 v);
+OVERLOADABLE long4 convert_long4(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4(uchar4 v);
+OVERLOADABLE int4 convert_int4(uchar4 v);
+OVERLOADABLE uint4 convert_uint4(uchar4 v);
+OVERLOADABLE short4 convert_short4(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4(uchar4 v);
+OVERLOADABLE char4 convert_char4(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4(uchar4 v);
+OVERLOADABLE double4 convert_double4(uchar4 v);
+OVERLOADABLE float4 convert_float4(uchar4 v);
+OVERLOADABLE half4 convert_half4(uchar4 v);
+OVERLOADABLE long4 convert_long4(double4 v);
+OVERLOADABLE ulong4 convert_ulong4(double4 v);
+OVERLOADABLE int4 convert_int4(double4 v);
+OVERLOADABLE uint4 convert_uint4(double4 v);
+OVERLOADABLE short4 convert_short4(double4 v);
+OVERLOADABLE ushort4 convert_ushort4(double4 v);
+OVERLOADABLE char4 convert_char4(double4 v);
+OVERLOADABLE uchar4 convert_uchar4(double4 v);
+OVERLOADABLE double4 convert_double4(double4 v);
+OVERLOADABLE float4 convert_float4(double4 v);
+OVERLOADABLE half4 convert_half4(double4 v);
+OVERLOADABLE long4 convert_long4(float4 v);
+OVERLOADABLE ulong4 convert_ulong4(float4 v);
+OVERLOADABLE int4 convert_int4(float4 v);
+OVERLOADABLE uint4 convert_uint4(float4 v);
+OVERLOADABLE short4 convert_short4(float4 v);
+OVERLOADABLE ushort4 convert_ushort4(float4 v);
+OVERLOADABLE char4 convert_char4(float4 v);
+OVERLOADABLE uchar4 convert_uchar4(float4 v);
+OVERLOADABLE double4 convert_double4(float4 v);
+OVERLOADABLE float4 convert_float4(float4 v);
+OVERLOADABLE half4 convert_half4(float4 v);
+OVERLOADABLE long4 convert_long4(half4 v);
+OVERLOADABLE ulong4 convert_ulong4(half4 v);
+OVERLOADABLE int4 convert_int4(half4 v);
+OVERLOADABLE uint4 convert_uint4(half4 v);
+OVERLOADABLE short4 convert_short4(half4 v);
+OVERLOADABLE ushort4 convert_ushort4(half4 v);
+OVERLOADABLE char4 convert_char4(half4 v);
+OVERLOADABLE uchar4 convert_uchar4(half4 v);
+OVERLOADABLE double4 convert_double4(half4 v);
+OVERLOADABLE float4 convert_float4(half4 v);
+OVERLOADABLE half4 convert_half4(half4 v);
+OVERLOADABLE long8 convert_long8(long8 v);
+OVERLOADABLE ulong8 convert_ulong8(long8 v);
+OVERLOADABLE int8 convert_int8(long8 v);
+OVERLOADABLE uint8 convert_uint8(long8 v);
+OVERLOADABLE short8 convert_short8(long8 v);
+OVERLOADABLE ushort8 convert_ushort8(long8 v);
+OVERLOADABLE char8 convert_char8(long8 v);
+OVERLOADABLE uchar8 convert_uchar8(long8 v);
+OVERLOADABLE double8 convert_double8(long8 v);
+OVERLOADABLE float8 convert_float8(long8 v);
+OVERLOADABLE half8 convert_half8(long8 v);
+OVERLOADABLE long8 convert_long8(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8(ulong8 v);
+OVERLOADABLE int8 convert_int8(ulong8 v);
+OVERLOADABLE uint8 convert_uint8(ulong8 v);
+OVERLOADABLE short8 convert_short8(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8(ulong8 v);
+OVERLOADABLE char8 convert_char8(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8(ulong8 v);
+OVERLOADABLE double8 convert_double8(ulong8 v);
+OVERLOADABLE float8 convert_float8(ulong8 v);
+OVERLOADABLE half8 convert_half8(ulong8 v);
+OVERLOADABLE long8 convert_long8(int8 v);
+OVERLOADABLE ulong8 convert_ulong8(int8 v);
+OVERLOADABLE int8 convert_int8(int8 v);
+OVERLOADABLE uint8 convert_uint8(int8 v);
+OVERLOADABLE short8 convert_short8(int8 v);
+OVERLOADABLE ushort8 convert_ushort8(int8 v);
+OVERLOADABLE char8 convert_char8(int8 v);
+OVERLOADABLE uchar8 convert_uchar8(int8 v);
+OVERLOADABLE double8 convert_double8(int8 v);
+OVERLOADABLE float8 convert_float8(int8 v);
+OVERLOADABLE half8 convert_half8(int8 v);
+OVERLOADABLE long8 convert_long8(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8(uint8 v);
+OVERLOADABLE int8 convert_int8(uint8 v);
+OVERLOADABLE uint8 convert_uint8(uint8 v);
+OVERLOADABLE short8 convert_short8(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8(uint8 v);
+OVERLOADABLE char8 convert_char8(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8(uint8 v);
+OVERLOADABLE double8 convert_double8(uint8 v);
+OVERLOADABLE float8 convert_float8(uint8 v);
+OVERLOADABLE half8 convert_half8(uint8 v);
+OVERLOADABLE long8 convert_long8(short8 v);
+OVERLOADABLE ulong8 convert_ulong8(short8 v);
+OVERLOADABLE int8 convert_int8(short8 v);
+OVERLOADABLE uint8 convert_uint8(short8 v);
+OVERLOADABLE short8 convert_short8(short8 v);
+OVERLOADABLE ushort8 convert_ushort8(short8 v);
+OVERLOADABLE char8 convert_char8(short8 v);
+OVERLOADABLE uchar8 convert_uchar8(short8 v);
+OVERLOADABLE double8 convert_double8(short8 v);
+OVERLOADABLE float8 convert_float8(short8 v);
+OVERLOADABLE half8 convert_half8(short8 v);
+OVERLOADABLE long8 convert_long8(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8(ushort8 v);
+OVERLOADABLE int8 convert_int8(ushort8 v);
+OVERLOADABLE uint8 convert_uint8(ushort8 v);
+OVERLOADABLE short8 convert_short8(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8(ushort8 v);
+OVERLOADABLE char8 convert_char8(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8(ushort8 v);
+OVERLOADABLE double8 convert_double8(ushort8 v);
+OVERLOADABLE float8 convert_float8(ushort8 v);
+OVERLOADABLE half8 convert_half8(ushort8 v);
+OVERLOADABLE long8 convert_long8(char8 v);
+OVERLOADABLE ulong8 convert_ulong8(char8 v);
+OVERLOADABLE int8 convert_int8(char8 v);
+OVERLOADABLE uint8 convert_uint8(char8 v);
+OVERLOADABLE short8 convert_short8(char8 v);
+OVERLOADABLE ushort8 convert_ushort8(char8 v);
+OVERLOADABLE char8 convert_char8(char8 v);
+OVERLOADABLE uchar8 convert_uchar8(char8 v);
+OVERLOADABLE double8 convert_double8(char8 v);
+OVERLOADABLE float8 convert_float8(char8 v);
+OVERLOADABLE half8 convert_half8(char8 v);
+OVERLOADABLE long8 convert_long8(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8(uchar8 v);
+OVERLOADABLE int8 convert_int8(uchar8 v);
+OVERLOADABLE uint8 convert_uint8(uchar8 v);
+OVERLOADABLE short8 convert_short8(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8(uchar8 v);
+OVERLOADABLE char8 convert_char8(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8(uchar8 v);
+OVERLOADABLE double8 convert_double8(uchar8 v);
+OVERLOADABLE float8 convert_float8(uchar8 v);
+OVERLOADABLE half8 convert_half8(uchar8 v);
+OVERLOADABLE long8 convert_long8(double8 v);
+OVERLOADABLE ulong8 convert_ulong8(double8 v);
+OVERLOADABLE int8 convert_int8(double8 v);
+OVERLOADABLE uint8 convert_uint8(double8 v);
+OVERLOADABLE short8 convert_short8(double8 v);
+OVERLOADABLE ushort8 convert_ushort8(double8 v);
+OVERLOADABLE char8 convert_char8(double8 v);
+OVERLOADABLE uchar8 convert_uchar8(double8 v);
+OVERLOADABLE double8 convert_double8(double8 v);
+OVERLOADABLE float8 convert_float8(double8 v);
+OVERLOADABLE half8 convert_half8(double8 v);
+OVERLOADABLE long8 convert_long8(float8 v);
+OVERLOADABLE ulong8 convert_ulong8(float8 v);
+OVERLOADABLE int8 convert_int8(float8 v);
+OVERLOADABLE uint8 convert_uint8(float8 v);
+OVERLOADABLE short8 convert_short8(float8 v);
+OVERLOADABLE ushort8 convert_ushort8(float8 v);
+OVERLOADABLE char8 convert_char8(float8 v);
+OVERLOADABLE uchar8 convert_uchar8(float8 v);
+OVERLOADABLE double8 convert_double8(float8 v);
+OVERLOADABLE float8 convert_float8(float8 v);
+OVERLOADABLE half8 convert_half8(float8 v);
+OVERLOADABLE long8 convert_long8(half8 v);
+OVERLOADABLE ulong8 convert_ulong8(half8 v);
+OVERLOADABLE int8 convert_int8(half8 v);
+OVERLOADABLE uint8 convert_uint8(half8 v);
+OVERLOADABLE short8 convert_short8(half8 v);
+OVERLOADABLE ushort8 convert_ushort8(half8 v);
+OVERLOADABLE char8 convert_char8(half8 v);
+OVERLOADABLE uchar8 convert_uchar8(half8 v);
+OVERLOADABLE double8 convert_double8(half8 v);
+OVERLOADABLE float8 convert_float8(half8 v);
+OVERLOADABLE half8 convert_half8(half8 v);
+OVERLOADABLE long16 convert_long16(long16 v);
+OVERLOADABLE ulong16 convert_ulong16(long16 v);
+OVERLOADABLE int16 convert_int16(long16 v);
+OVERLOADABLE uint16 convert_uint16(long16 v);
+OVERLOADABLE short16 convert_short16(long16 v);
+OVERLOADABLE ushort16 convert_ushort16(long16 v);
+OVERLOADABLE char16 convert_char16(long16 v);
+OVERLOADABLE uchar16 convert_uchar16(long16 v);
+OVERLOADABLE double16 convert_double16(long16 v);
+OVERLOADABLE float16 convert_float16(long16 v);
+OVERLOADABLE half16 convert_half16(long16 v);
+OVERLOADABLE long16 convert_long16(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16(ulong16 v);
+OVERLOADABLE int16 convert_int16(ulong16 v);
+OVERLOADABLE uint16 convert_uint16(ulong16 v);
+OVERLOADABLE short16 convert_short16(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16(ulong16 v);
+OVERLOADABLE char16 convert_char16(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16(ulong16 v);
+OVERLOADABLE double16 convert_double16(ulong16 v);
+OVERLOADABLE float16 convert_float16(ulong16 v);
+OVERLOADABLE half16 convert_half16(ulong16 v);
+OVERLOADABLE long16 convert_long16(int16 v);
+OVERLOADABLE ulong16 convert_ulong16(int16 v);
+OVERLOADABLE int16 convert_int16(int16 v);
+OVERLOADABLE uint16 convert_uint16(int16 v);
+OVERLOADABLE short16 convert_short16(int16 v);
+OVERLOADABLE ushort16 convert_ushort16(int16 v);
+OVERLOADABLE char16 convert_char16(int16 v);
+OVERLOADABLE uchar16 convert_uchar16(int16 v);
+OVERLOADABLE double16 convert_double16(int16 v);
+OVERLOADABLE float16 convert_float16(int16 v);
+OVERLOADABLE half16 convert_half16(int16 v);
+OVERLOADABLE long16 convert_long16(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16(uint16 v);
+OVERLOADABLE int16 convert_int16(uint16 v);
+OVERLOADABLE uint16 convert_uint16(uint16 v);
+OVERLOADABLE short16 convert_short16(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16(uint16 v);
+OVERLOADABLE char16 convert_char16(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16(uint16 v);
+OVERLOADABLE double16 convert_double16(uint16 v);
+OVERLOADABLE float16 convert_float16(uint16 v);
+OVERLOADABLE half16 convert_half16(uint16 v);
+OVERLOADABLE long16 convert_long16(short16 v);
+OVERLOADABLE ulong16 convert_ulong16(short16 v);
+OVERLOADABLE int16 convert_int16(short16 v);
+OVERLOADABLE uint16 convert_uint16(short16 v);
+OVERLOADABLE short16 convert_short16(short16 v);
+OVERLOADABLE ushort16 convert_ushort16(short16 v);
+OVERLOADABLE char16 convert_char16(short16 v);
+OVERLOADABLE uchar16 convert_uchar16(short16 v);
+OVERLOADABLE double16 convert_double16(short16 v);
+OVERLOADABLE float16 convert_float16(short16 v);
+OVERLOADABLE half16 convert_half16(short16 v);
+OVERLOADABLE long16 convert_long16(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16(ushort16 v);
+OVERLOADABLE int16 convert_int16(ushort16 v);
+OVERLOADABLE uint16 convert_uint16(ushort16 v);
+OVERLOADABLE short16 convert_short16(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16(ushort16 v);
+OVERLOADABLE char16 convert_char16(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16(ushort16 v);
+OVERLOADABLE double16 convert_double16(ushort16 v);
+OVERLOADABLE float16 convert_float16(ushort16 v);
+OVERLOADABLE half16 convert_half16(ushort16 v);
+OVERLOADABLE long16 convert_long16(char16 v);
+OVERLOADABLE ulong16 convert_ulong16(char16 v);
+OVERLOADABLE int16 convert_int16(char16 v);
+OVERLOADABLE uint16 convert_uint16(char16 v);
+OVERLOADABLE short16 convert_short16(char16 v);
+OVERLOADABLE ushort16 convert_ushort16(char16 v);
+OVERLOADABLE char16 convert_char16(char16 v);
+OVERLOADABLE uchar16 convert_uchar16(char16 v);
+OVERLOADABLE double16 convert_double16(char16 v);
+OVERLOADABLE float16 convert_float16(char16 v);
+OVERLOADABLE half16 convert_half16(char16 v);
+OVERLOADABLE long16 convert_long16(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16(uchar16 v);
+OVERLOADABLE int16 convert_int16(uchar16 v);
+OVERLOADABLE uint16 convert_uint16(uchar16 v);
+OVERLOADABLE short16 convert_short16(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16(uchar16 v);
+OVERLOADABLE char16 convert_char16(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16(uchar16 v);
+OVERLOADABLE double16 convert_double16(uchar16 v);
+OVERLOADABLE float16 convert_float16(uchar16 v);
+OVERLOADABLE half16 convert_half16(uchar16 v);
+OVERLOADABLE long16 convert_long16(double16 v);
+OVERLOADABLE ulong16 convert_ulong16(double16 v);
+OVERLOADABLE int16 convert_int16(double16 v);
+OVERLOADABLE uint16 convert_uint16(double16 v);
+OVERLOADABLE short16 convert_short16(double16 v);
+OVERLOADABLE ushort16 convert_ushort16(double16 v);
+OVERLOADABLE char16 convert_char16(double16 v);
+OVERLOADABLE uchar16 convert_uchar16(double16 v);
+OVERLOADABLE double16 convert_double16(double16 v);
+OVERLOADABLE float16 convert_float16(double16 v);
+OVERLOADABLE half16 convert_half16(double16 v);
+OVERLOADABLE long16 convert_long16(float16 v);
+OVERLOADABLE ulong16 convert_ulong16(float16 v);
+OVERLOADABLE int16 convert_int16(float16 v);
+OVERLOADABLE uint16 convert_uint16(float16 v);
+OVERLOADABLE short16 convert_short16(float16 v);
+OVERLOADABLE ushort16 convert_ushort16(float16 v);
+OVERLOADABLE char16 convert_char16(float16 v);
+OVERLOADABLE uchar16 convert_uchar16(float16 v);
+OVERLOADABLE double16 convert_double16(float16 v);
+OVERLOADABLE float16 convert_float16(float16 v);
+OVERLOADABLE half16 convert_half16(float16 v);
+OVERLOADABLE long16 convert_long16(half16 v);
+OVERLOADABLE ulong16 convert_ulong16(half16 v);
+OVERLOADABLE int16 convert_int16(half16 v);
+OVERLOADABLE uint16 convert_uint16(half16 v);
+OVERLOADABLE short16 convert_short16(half16 v);
+OVERLOADABLE ushort16 convert_ushort16(half16 v);
+OVERLOADABLE char16 convert_char16(half16 v);
+OVERLOADABLE uchar16 convert_uchar16(half16 v);
+OVERLOADABLE double16 convert_double16(half16 v);
+OVERLOADABLE float16 convert_float16(half16 v);
+OVERLOADABLE half16 convert_half16(half16 v);
+
+/* The sat cvt supported by HW. */
+#define DEF(DSTTYPE, SRCTYPE) \
+OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x);
+DEF(char, uchar);
+DEF(char, short);
+DEF(char, ushort);
+DEF(char, int);
+DEF(char, uint);
+DEF(char, float);
+DEF(uchar, char);
+DEF(uchar, short);
+DEF(uchar, ushort);
+DEF(uchar, int);
+DEF(uchar, uint);
+DEF(uchar, float);
+DEF(short, ushort);
+DEF(short, int);
+DEF(short, uint);
+DEF(short, float);
+DEF(short, double);
+DEF(ushort, short);
+DEF(ushort, int);
+DEF(ushort, uint);
+DEF(ushort, float);
+DEF(ushort, double);
+DEF(int, uint);
+DEF(int, float);
+DEF(int, double);
+DEF(uint, int);
+DEF(uint, float);
+DEF(uint, double);
+DEF(char, half);
+DEF(uchar, half);
+DEF(short, half);
+DEF(ushort, half);
+DEF(int, half);
+DEF(uint, half);
+#undef DEF
+
+#define DEF(DSTTYPE, SRCTYPE, MIN, MAX)  OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x);
+
+DEF(char, long, -128, 127);
+DEF(uchar, long, 0, 255);
+DEF(short, long, -32768, 32767);
+DEF(ushort, long, 0, 65535);
+DEF(int, long, -0x7fffffff-1, 0x7fffffff);
+DEF(uint, long, 0, 0xffffffffu);
+#undef DEF
+
+
+#define DEF(DSTTYPE, SRCTYPE, SRC_MIN, SRC_MAX, DST_MIN, DST_MAX) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x);
+
+DEF(long, float, -0x1.0p63, 0x1.0p63, 0x8000000000000000, 0x7fffffffffffffff);
+DEF(ulong, float, 0, 0x1.0p64, 0, 0xffffffffffffffff);
+DEF(char, double, -0x1.0p7, 0x1.0p7,  0x80, 0x7F);
+DEF(uchar, double, 0, 0x1.0p8, 0, 0xFF);
+DEF(long, double, -0x1.0p63, 0x1.0p63, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF);
+DEF(ulong, double, 0, 0x1.0p64, 0, 0xFFFFFFFFFFFFFFFF);
+#undef DEF
+
+#define DEF(DSTTYPE, SRCTYPE, MAX) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x);
+
+DEF(char, ulong, 127);
+DEF(uchar, ulong, 255);
+DEF(short, ulong, 32767);
+DEF(ushort, ulong, 65535);
+DEF(int, ulong, 0x7fffffff);
+DEF(uint, ulong, 0xffffffffu);
+#undef DEF
+
+OVERLOADABLE long convert_long_sat(ulong x);
+#define DEF(DSTTYPE, SRCTYPE) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x);
+
+  DEF(ushort, char);
+  DEF(uint, char);
+  DEF(uint, short);
+  DEF(ulong, char);
+  DEF(ulong, short);
+  DEF(ulong, int);
+  DEF(ulong, long);
+  #undef DEF
+
+#define DEF(DSTTYPE, SRCTYPE) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x);
+
+DEF(char, char);
+DEF(uchar, uchar);
+DEF(short, char);
+DEF(short, uchar);
+DEF(short, short);
+DEF(ushort, uchar);
+DEF(ushort, ushort);
+DEF(int, char);
+DEF(int, uchar);
+DEF(int, short);
+DEF(int, ushort);
+DEF(int, int);
+DEF(uint, uchar);
+DEF(uint, ushort);
+DEF(uint, uint);
+DEF(long, char);
+DEF(long, uchar);
+DEF(long, short);
+DEF(long, ushort);
+DEF(long, int);
+DEF(long, uint);
+DEF(long, long);
+DEF(ulong, uchar);
+DEF(ulong, ushort);
+DEF(ulong, uint);
+DEF(ulong, ulong);
+#undef DEF
+
+
+       OVERLOADABLE long convert_long_sat(half x);
+       OVERLOADABLE ulong convert_ulong_sat(half x);
+       
+OVERLOADABLE long2 convert_long2_sat(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(long2 v);
+OVERLOADABLE int2 convert_int2_sat(long2 v);
+OVERLOADABLE uint2 convert_uint2_sat(long2 v);
+OVERLOADABLE short2 convert_short2_sat(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(long2 v);
+OVERLOADABLE char2 convert_char2_sat(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(long2 v);
+OVERLOADABLE long2 convert_long2_sat(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(ulong2 v);
+OVERLOADABLE int2 convert_int2_sat(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_sat(ulong2 v);
+OVERLOADABLE short2 convert_short2_sat(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(ulong2 v);
+OVERLOADABLE char2 convert_char2_sat(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(ulong2 v);
+OVERLOADABLE long2 convert_long2_sat(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(int2 v);
+OVERLOADABLE int2 convert_int2_sat(int2 v);
+OVERLOADABLE uint2 convert_uint2_sat(int2 v);
+OVERLOADABLE short2 convert_short2_sat(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(int2 v);
+OVERLOADABLE char2 convert_char2_sat(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(int2 v);
+OVERLOADABLE long2 convert_long2_sat(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(uint2 v);
+OVERLOADABLE int2 convert_int2_sat(uint2 v);
+OVERLOADABLE uint2 convert_uint2_sat(uint2 v);
+OVERLOADABLE short2 convert_short2_sat(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(uint2 v);
+OVERLOADABLE char2 convert_char2_sat(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(uint2 v);
+OVERLOADABLE long2 convert_long2_sat(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(short2 v);
+OVERLOADABLE int2 convert_int2_sat(short2 v);
+OVERLOADABLE uint2 convert_uint2_sat(short2 v);
+OVERLOADABLE short2 convert_short2_sat(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(short2 v);
+OVERLOADABLE char2 convert_char2_sat(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(short2 v);
+OVERLOADABLE long2 convert_long2_sat(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(ushort2 v);
+OVERLOADABLE int2 convert_int2_sat(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_sat(ushort2 v);
+OVERLOADABLE short2 convert_short2_sat(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(ushort2 v);
+OVERLOADABLE char2 convert_char2_sat(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(ushort2 v);
+OVERLOADABLE long2 convert_long2_sat(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(char2 v);
+OVERLOADABLE int2 convert_int2_sat(char2 v);
+OVERLOADABLE uint2 convert_uint2_sat(char2 v);
+OVERLOADABLE short2 convert_short2_sat(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(char2 v);
+OVERLOADABLE char2 convert_char2_sat(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(char2 v);
+OVERLOADABLE long2 convert_long2_sat(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(uchar2 v);
+OVERLOADABLE int2 convert_int2_sat(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_sat(uchar2 v);
+OVERLOADABLE short2 convert_short2_sat(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(uchar2 v);
+OVERLOADABLE char2 convert_char2_sat(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(uchar2 v);
+OVERLOADABLE long2 convert_long2_sat(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(double2 v);
+OVERLOADABLE int2 convert_int2_sat(double2 v);
+OVERLOADABLE uint2 convert_uint2_sat(double2 v);
+OVERLOADABLE short2 convert_short2_sat(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(double2 v);
+OVERLOADABLE char2 convert_char2_sat(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(double2 v);
+OVERLOADABLE long2 convert_long2_sat(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(float2 v);
+OVERLOADABLE int2 convert_int2_sat(float2 v);
+OVERLOADABLE uint2 convert_uint2_sat(float2 v);
+OVERLOADABLE short2 convert_short2_sat(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(float2 v);
+OVERLOADABLE char2 convert_char2_sat(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(float2 v);
+OVERLOADABLE long2 convert_long2_sat(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat(half2 v);
+OVERLOADABLE int2 convert_int2_sat(half2 v);
+OVERLOADABLE uint2 convert_uint2_sat(half2 v);
+OVERLOADABLE short2 convert_short2_sat(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat(half2 v);
+OVERLOADABLE char2 convert_char2_sat(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat(half2 v);
+OVERLOADABLE long3 convert_long3_sat(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(long3 v);
+OVERLOADABLE int3 convert_int3_sat(long3 v);
+OVERLOADABLE uint3 convert_uint3_sat(long3 v);
+OVERLOADABLE short3 convert_short3_sat(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(long3 v);
+OVERLOADABLE char3 convert_char3_sat(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(long3 v);
+OVERLOADABLE long3 convert_long3_sat(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(ulong3 v);
+OVERLOADABLE int3 convert_int3_sat(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_sat(ulong3 v);
+OVERLOADABLE short3 convert_short3_sat(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(ulong3 v);
+OVERLOADABLE char3 convert_char3_sat(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(ulong3 v);
+OVERLOADABLE long3 convert_long3_sat(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(int3 v);
+OVERLOADABLE int3 convert_int3_sat(int3 v);
+OVERLOADABLE uint3 convert_uint3_sat(int3 v);
+OVERLOADABLE short3 convert_short3_sat(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(int3 v);
+OVERLOADABLE char3 convert_char3_sat(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(int3 v);
+OVERLOADABLE long3 convert_long3_sat(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(uint3 v);
+OVERLOADABLE int3 convert_int3_sat(uint3 v);
+OVERLOADABLE uint3 convert_uint3_sat(uint3 v);
+OVERLOADABLE short3 convert_short3_sat(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(uint3 v);
+OVERLOADABLE char3 convert_char3_sat(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(uint3 v);
+OVERLOADABLE long3 convert_long3_sat(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(short3 v);
+OVERLOADABLE int3 convert_int3_sat(short3 v);
+OVERLOADABLE uint3 convert_uint3_sat(short3 v);
+OVERLOADABLE short3 convert_short3_sat(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(short3 v);
+OVERLOADABLE char3 convert_char3_sat(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(short3 v);
+OVERLOADABLE long3 convert_long3_sat(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(ushort3 v);
+OVERLOADABLE int3 convert_int3_sat(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_sat(ushort3 v);
+OVERLOADABLE short3 convert_short3_sat(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(ushort3 v);
+OVERLOADABLE char3 convert_char3_sat(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(ushort3 v);
+OVERLOADABLE long3 convert_long3_sat(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(char3 v);
+OVERLOADABLE int3 convert_int3_sat(char3 v);
+OVERLOADABLE uint3 convert_uint3_sat(char3 v);
+OVERLOADABLE short3 convert_short3_sat(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(char3 v);
+OVERLOADABLE char3 convert_char3_sat(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(char3 v);
+OVERLOADABLE long3 convert_long3_sat(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(uchar3 v);
+OVERLOADABLE int3 convert_int3_sat(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_sat(uchar3 v);
+OVERLOADABLE short3 convert_short3_sat(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(uchar3 v);
+OVERLOADABLE char3 convert_char3_sat(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(uchar3 v);
+OVERLOADABLE long3 convert_long3_sat(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(double3 v);
+OVERLOADABLE int3 convert_int3_sat(double3 v);
+OVERLOADABLE uint3 convert_uint3_sat(double3 v);
+OVERLOADABLE short3 convert_short3_sat(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(double3 v);
+OVERLOADABLE char3 convert_char3_sat(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(double3 v);
+OVERLOADABLE long3 convert_long3_sat(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(float3 v);
+OVERLOADABLE int3 convert_int3_sat(float3 v);
+OVERLOADABLE uint3 convert_uint3_sat(float3 v);
+OVERLOADABLE short3 convert_short3_sat(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(float3 v);
+OVERLOADABLE char3 convert_char3_sat(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(float3 v);
+OVERLOADABLE long3 convert_long3_sat(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat(half3 v);
+OVERLOADABLE int3 convert_int3_sat(half3 v);
+OVERLOADABLE uint3 convert_uint3_sat(half3 v);
+OVERLOADABLE short3 convert_short3_sat(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat(half3 v);
+OVERLOADABLE char3 convert_char3_sat(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat(half3 v);
+OVERLOADABLE long4 convert_long4_sat(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(long4 v);
+OVERLOADABLE int4 convert_int4_sat(long4 v);
+OVERLOADABLE uint4 convert_uint4_sat(long4 v);
+OVERLOADABLE short4 convert_short4_sat(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(long4 v);
+OVERLOADABLE char4 convert_char4_sat(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(long4 v);
+OVERLOADABLE long4 convert_long4_sat(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(ulong4 v);
+OVERLOADABLE int4 convert_int4_sat(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_sat(ulong4 v);
+OVERLOADABLE short4 convert_short4_sat(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(ulong4 v);
+OVERLOADABLE char4 convert_char4_sat(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(ulong4 v);
+OVERLOADABLE long4 convert_long4_sat(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(int4 v);
+OVERLOADABLE int4 convert_int4_sat(int4 v);
+OVERLOADABLE uint4 convert_uint4_sat(int4 v);
+OVERLOADABLE short4 convert_short4_sat(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(int4 v);
+OVERLOADABLE char4 convert_char4_sat(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(int4 v);
+OVERLOADABLE long4 convert_long4_sat(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(uint4 v);
+OVERLOADABLE int4 convert_int4_sat(uint4 v);
+OVERLOADABLE uint4 convert_uint4_sat(uint4 v);
+OVERLOADABLE short4 convert_short4_sat(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(uint4 v);
+OVERLOADABLE char4 convert_char4_sat(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(uint4 v);
+OVERLOADABLE long4 convert_long4_sat(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(short4 v);
+OVERLOADABLE int4 convert_int4_sat(short4 v);
+OVERLOADABLE uint4 convert_uint4_sat(short4 v);
+OVERLOADABLE short4 convert_short4_sat(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(short4 v);
+OVERLOADABLE char4 convert_char4_sat(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(short4 v);
+OVERLOADABLE long4 convert_long4_sat(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(ushort4 v);
+OVERLOADABLE int4 convert_int4_sat(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_sat(ushort4 v);
+OVERLOADABLE short4 convert_short4_sat(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(ushort4 v);
+OVERLOADABLE char4 convert_char4_sat(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(ushort4 v);
+OVERLOADABLE long4 convert_long4_sat(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(char4 v);
+OVERLOADABLE int4 convert_int4_sat(char4 v);
+OVERLOADABLE uint4 convert_uint4_sat(char4 v);
+OVERLOADABLE short4 convert_short4_sat(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(char4 v);
+OVERLOADABLE char4 convert_char4_sat(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(char4 v);
+OVERLOADABLE long4 convert_long4_sat(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(uchar4 v);
+OVERLOADABLE int4 convert_int4_sat(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_sat(uchar4 v);
+OVERLOADABLE short4 convert_short4_sat(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(uchar4 v);
+OVERLOADABLE char4 convert_char4_sat(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(uchar4 v);
+OVERLOADABLE long4 convert_long4_sat(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(double4 v);
+OVERLOADABLE int4 convert_int4_sat(double4 v);
+OVERLOADABLE uint4 convert_uint4_sat(double4 v);
+OVERLOADABLE short4 convert_short4_sat(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(double4 v);
+OVERLOADABLE char4 convert_char4_sat(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(double4 v);
+OVERLOADABLE long4 convert_long4_sat(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(float4 v);
+OVERLOADABLE int4 convert_int4_sat(float4 v);
+OVERLOADABLE uint4 convert_uint4_sat(float4 v);
+OVERLOADABLE short4 convert_short4_sat(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(float4 v);
+OVERLOADABLE char4 convert_char4_sat(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(float4 v);
+OVERLOADABLE long4 convert_long4_sat(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat(half4 v);
+OVERLOADABLE int4 convert_int4_sat(half4 v);
+OVERLOADABLE uint4 convert_uint4_sat(half4 v);
+OVERLOADABLE short4 convert_short4_sat(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat(half4 v);
+OVERLOADABLE char4 convert_char4_sat(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat(half4 v);
+OVERLOADABLE long8 convert_long8_sat(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(long8 v);
+OVERLOADABLE int8 convert_int8_sat(long8 v);
+OVERLOADABLE uint8 convert_uint8_sat(long8 v);
+OVERLOADABLE short8 convert_short8_sat(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(long8 v);
+OVERLOADABLE char8 convert_char8_sat(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(long8 v);
+OVERLOADABLE long8 convert_long8_sat(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(ulong8 v);
+OVERLOADABLE int8 convert_int8_sat(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_sat(ulong8 v);
+OVERLOADABLE short8 convert_short8_sat(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(ulong8 v);
+OVERLOADABLE char8 convert_char8_sat(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(ulong8 v);
+OVERLOADABLE long8 convert_long8_sat(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(int8 v);
+OVERLOADABLE int8 convert_int8_sat(int8 v);
+OVERLOADABLE uint8 convert_uint8_sat(int8 v);
+OVERLOADABLE short8 convert_short8_sat(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(int8 v);
+OVERLOADABLE char8 convert_char8_sat(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(int8 v);
+OVERLOADABLE long8 convert_long8_sat(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(uint8 v);
+OVERLOADABLE int8 convert_int8_sat(uint8 v);
+OVERLOADABLE uint8 convert_uint8_sat(uint8 v);
+OVERLOADABLE short8 convert_short8_sat(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(uint8 v);
+OVERLOADABLE char8 convert_char8_sat(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(uint8 v);
+OVERLOADABLE long8 convert_long8_sat(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(short8 v);
+OVERLOADABLE int8 convert_int8_sat(short8 v);
+OVERLOADABLE uint8 convert_uint8_sat(short8 v);
+OVERLOADABLE short8 convert_short8_sat(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(short8 v);
+OVERLOADABLE char8 convert_char8_sat(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(short8 v);
+OVERLOADABLE long8 convert_long8_sat(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(ushort8 v);
+OVERLOADABLE int8 convert_int8_sat(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_sat(ushort8 v);
+OVERLOADABLE short8 convert_short8_sat(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(ushort8 v);
+OVERLOADABLE char8 convert_char8_sat(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(ushort8 v);
+OVERLOADABLE long8 convert_long8_sat(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(char8 v);
+OVERLOADABLE int8 convert_int8_sat(char8 v);
+OVERLOADABLE uint8 convert_uint8_sat(char8 v);
+OVERLOADABLE short8 convert_short8_sat(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(char8 v);
+OVERLOADABLE char8 convert_char8_sat(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(char8 v);
+OVERLOADABLE long8 convert_long8_sat(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(uchar8 v);
+OVERLOADABLE int8 convert_int8_sat(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_sat(uchar8 v);
+OVERLOADABLE short8 convert_short8_sat(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(uchar8 v);
+OVERLOADABLE char8 convert_char8_sat(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(uchar8 v);
+OVERLOADABLE long8 convert_long8_sat(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(double8 v);
+OVERLOADABLE int8 convert_int8_sat(double8 v);
+OVERLOADABLE uint8 convert_uint8_sat(double8 v);
+OVERLOADABLE short8 convert_short8_sat(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(double8 v);
+OVERLOADABLE char8 convert_char8_sat(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(double8 v);
+OVERLOADABLE long8 convert_long8_sat(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(float8 v);
+OVERLOADABLE int8 convert_int8_sat(float8 v);
+OVERLOADABLE uint8 convert_uint8_sat(float8 v);
+OVERLOADABLE short8 convert_short8_sat(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(float8 v);
+OVERLOADABLE char8 convert_char8_sat(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(float8 v);
+OVERLOADABLE long8 convert_long8_sat(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat(half8 v);
+OVERLOADABLE int8 convert_int8_sat(half8 v);
+OVERLOADABLE uint8 convert_uint8_sat(half8 v);
+OVERLOADABLE short8 convert_short8_sat(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat(half8 v);
+OVERLOADABLE char8 convert_char8_sat(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat(half8 v);
+OVERLOADABLE long16 convert_long16_sat(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(long16 v);
+OVERLOADABLE int16 convert_int16_sat(long16 v);
+OVERLOADABLE uint16 convert_uint16_sat(long16 v);
+OVERLOADABLE short16 convert_short16_sat(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(long16 v);
+OVERLOADABLE char16 convert_char16_sat(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(long16 v);
+OVERLOADABLE long16 convert_long16_sat(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(ulong16 v);
+OVERLOADABLE int16 convert_int16_sat(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_sat(ulong16 v);
+OVERLOADABLE short16 convert_short16_sat(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(ulong16 v);
+OVERLOADABLE char16 convert_char16_sat(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(ulong16 v);
+OVERLOADABLE long16 convert_long16_sat(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(int16 v);
+OVERLOADABLE int16 convert_int16_sat(int16 v);
+OVERLOADABLE uint16 convert_uint16_sat(int16 v);
+OVERLOADABLE short16 convert_short16_sat(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(int16 v);
+OVERLOADABLE char16 convert_char16_sat(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(int16 v);
+OVERLOADABLE long16 convert_long16_sat(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(uint16 v);
+OVERLOADABLE int16 convert_int16_sat(uint16 v);
+OVERLOADABLE uint16 convert_uint16_sat(uint16 v);
+OVERLOADABLE short16 convert_short16_sat(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(uint16 v);
+OVERLOADABLE char16 convert_char16_sat(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(uint16 v);
+OVERLOADABLE long16 convert_long16_sat(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(short16 v);
+OVERLOADABLE int16 convert_int16_sat(short16 v);
+OVERLOADABLE uint16 convert_uint16_sat(short16 v);
+OVERLOADABLE short16 convert_short16_sat(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(short16 v);
+OVERLOADABLE char16 convert_char16_sat(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(short16 v);
+OVERLOADABLE long16 convert_long16_sat(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(ushort16 v);
+OVERLOADABLE int16 convert_int16_sat(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_sat(ushort16 v);
+OVERLOADABLE short16 convert_short16_sat(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(ushort16 v);
+OVERLOADABLE char16 convert_char16_sat(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(ushort16 v);
+OVERLOADABLE long16 convert_long16_sat(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(char16 v);
+OVERLOADABLE int16 convert_int16_sat(char16 v);
+OVERLOADABLE uint16 convert_uint16_sat(char16 v);
+OVERLOADABLE short16 convert_short16_sat(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(char16 v);
+OVERLOADABLE char16 convert_char16_sat(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(char16 v);
+OVERLOADABLE long16 convert_long16_sat(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(uchar16 v);
+OVERLOADABLE int16 convert_int16_sat(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_sat(uchar16 v);
+OVERLOADABLE short16 convert_short16_sat(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(uchar16 v);
+OVERLOADABLE char16 convert_char16_sat(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(uchar16 v);
+OVERLOADABLE long16 convert_long16_sat(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(double16 v);
+OVERLOADABLE int16 convert_int16_sat(double16 v);
+OVERLOADABLE uint16 convert_uint16_sat(double16 v);
+OVERLOADABLE short16 convert_short16_sat(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(double16 v);
+OVERLOADABLE char16 convert_char16_sat(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(double16 v);
+OVERLOADABLE long16 convert_long16_sat(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(float16 v);
+OVERLOADABLE int16 convert_int16_sat(float16 v);
+OVERLOADABLE uint16 convert_uint16_sat(float16 v);
+OVERLOADABLE short16 convert_short16_sat(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(float16 v);
+OVERLOADABLE char16 convert_char16_sat(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(float16 v);
+OVERLOADABLE long16 convert_long16_sat(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat(half16 v);
+OVERLOADABLE int16 convert_int16_sat(half16 v);
+OVERLOADABLE uint16 convert_uint16_sat(half16 v);
+OVERLOADABLE short16 convert_short16_sat(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat(half16 v);
+OVERLOADABLE char16 convert_char16_sat(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat(half16 v);
+OVERLOADABLE long convert_long_rte(long x);
+OVERLOADABLE long convert_long_rtz(long x);
+OVERLOADABLE long convert_long_rtp(long x);
+OVERLOADABLE long convert_long_rtn(long x);
+OVERLOADABLE ulong convert_ulong_rte(long x);
+OVERLOADABLE ulong convert_ulong_rtz(long x);
+OVERLOADABLE ulong convert_ulong_rtp(long x);
+OVERLOADABLE ulong convert_ulong_rtn(long x);
+OVERLOADABLE int convert_int_rte(long x);
+OVERLOADABLE int convert_int_rtz(long x);
+OVERLOADABLE int convert_int_rtp(long x);
+OVERLOADABLE int convert_int_rtn(long x);
+OVERLOADABLE uint convert_uint_rte(long x);
+OVERLOADABLE uint convert_uint_rtz(long x);
+OVERLOADABLE uint convert_uint_rtp(long x);
+OVERLOADABLE uint convert_uint_rtn(long x);
+OVERLOADABLE short convert_short_rte(long x);
+OVERLOADABLE short convert_short_rtz(long x);
+OVERLOADABLE short convert_short_rtp(long x);
+OVERLOADABLE short convert_short_rtn(long x);
+OVERLOADABLE ushort convert_ushort_rte(long x);
+OVERLOADABLE ushort convert_ushort_rtz(long x);
+OVERLOADABLE ushort convert_ushort_rtp(long x);
+OVERLOADABLE ushort convert_ushort_rtn(long x);
+OVERLOADABLE char convert_char_rte(long x);
+OVERLOADABLE char convert_char_rtz(long x);
+OVERLOADABLE char convert_char_rtp(long x);
+OVERLOADABLE char convert_char_rtn(long x);
+OVERLOADABLE uchar convert_uchar_rte(long x);
+OVERLOADABLE uchar convert_uchar_rtz(long x);
+OVERLOADABLE uchar convert_uchar_rtp(long x);
+OVERLOADABLE uchar convert_uchar_rtn(long x);
+OVERLOADABLE float convert_float_rte(long x);
+OVERLOADABLE float convert_float_rtz(long x);
+OVERLOADABLE float convert_float_rtp(long x);
+OVERLOADABLE float convert_float_rtn(long x);
+OVERLOADABLE half convert_half_rte(long x);
+OVERLOADABLE half convert_half_rtz(long x);
+OVERLOADABLE half convert_half_rtp(long x);
+OVERLOADABLE half convert_half_rtn(long x);
+OVERLOADABLE long convert_long_rte(ulong x);
+OVERLOADABLE long convert_long_rtz(ulong x);
+OVERLOADABLE long convert_long_rtp(ulong x);
+OVERLOADABLE long convert_long_rtn(ulong x);
+OVERLOADABLE ulong convert_ulong_rte(ulong x);
+OVERLOADABLE ulong convert_ulong_rtz(ulong x);
+OVERLOADABLE ulong convert_ulong_rtp(ulong x);
+OVERLOADABLE ulong convert_ulong_rtn(ulong x);
+OVERLOADABLE int convert_int_rte(ulong x);
+OVERLOADABLE int convert_int_rtz(ulong x);
+OVERLOADABLE int convert_int_rtp(ulong x);
+OVERLOADABLE int convert_int_rtn(ulong x);
+OVERLOADABLE uint convert_uint_rte(ulong x);
+OVERLOADABLE uint convert_uint_rtz(ulong x);
+OVERLOADABLE uint convert_uint_rtp(ulong x);
+OVERLOADABLE uint convert_uint_rtn(ulong x);
+OVERLOADABLE short convert_short_rte(ulong x);
+OVERLOADABLE short convert_short_rtz(ulong x);
+OVERLOADABLE short convert_short_rtp(ulong x);
+OVERLOADABLE short convert_short_rtn(ulong x);
+OVERLOADABLE ushort convert_ushort_rte(ulong x);
+OVERLOADABLE ushort convert_ushort_rtz(ulong x);
+OVERLOADABLE ushort convert_ushort_rtp(ulong x);
+OVERLOADABLE ushort convert_ushort_rtn(ulong x);
+OVERLOADABLE char convert_char_rte(ulong x);
+OVERLOADABLE char convert_char_rtz(ulong x);
+OVERLOADABLE char convert_char_rtp(ulong x);
+OVERLOADABLE char convert_char_rtn(ulong x);
+OVERLOADABLE uchar convert_uchar_rte(ulong x);
+OVERLOADABLE uchar convert_uchar_rtz(ulong x);
+OVERLOADABLE uchar convert_uchar_rtp(ulong x);
+OVERLOADABLE uchar convert_uchar_rtn(ulong x);
+OVERLOADABLE float convert_float_rte(ulong x);
+OVERLOADABLE float convert_float_rtz(ulong x);
+OVERLOADABLE float convert_float_rtp(ulong x);
+OVERLOADABLE float convert_float_rtn(ulong x);
+OVERLOADABLE half convert_half_rte(ulong x);
+OVERLOADABLE half convert_half_rtz(ulong x);
+OVERLOADABLE half convert_half_rtp(ulong x);
+OVERLOADABLE half convert_half_rtn(ulong x);
+OVERLOADABLE long convert_long_rte(int x);
+OVERLOADABLE long convert_long_rtz(int x);
+OVERLOADABLE long convert_long_rtp(int x);
+OVERLOADABLE long convert_long_rtn(int x);
+OVERLOADABLE ulong convert_ulong_rte(int x);
+OVERLOADABLE ulong convert_ulong_rtz(int x);
+OVERLOADABLE ulong convert_ulong_rtp(int x);
+OVERLOADABLE ulong convert_ulong_rtn(int x);
+OVERLOADABLE int convert_int_rte(int x);
+OVERLOADABLE int convert_int_rtz(int x);
+OVERLOADABLE int convert_int_rtp(int x);
+OVERLOADABLE int convert_int_rtn(int x);
+OVERLOADABLE uint convert_uint_rte(int x);
+OVERLOADABLE uint convert_uint_rtz(int x);
+OVERLOADABLE uint convert_uint_rtp(int x);
+OVERLOADABLE uint convert_uint_rtn(int x);
+OVERLOADABLE short convert_short_rte(int x);
+OVERLOADABLE short convert_short_rtz(int x);
+OVERLOADABLE short convert_short_rtp(int x);
+OVERLOADABLE short convert_short_rtn(int x);
+OVERLOADABLE ushort convert_ushort_rte(int x);
+OVERLOADABLE ushort convert_ushort_rtz(int x);
+OVERLOADABLE ushort convert_ushort_rtp(int x);
+OVERLOADABLE ushort convert_ushort_rtn(int x);
+OVERLOADABLE char convert_char_rte(int x);
+OVERLOADABLE char convert_char_rtz(int x);
+OVERLOADABLE char convert_char_rtp(int x);
+OVERLOADABLE char convert_char_rtn(int x);
+OVERLOADABLE uchar convert_uchar_rte(int x);
+OVERLOADABLE uchar convert_uchar_rtz(int x);
+OVERLOADABLE uchar convert_uchar_rtp(int x);
+OVERLOADABLE uchar convert_uchar_rtn(int x);
+OVERLOADABLE float convert_float_rte(int x);
+OVERLOADABLE float convert_float_rtz(int x);
+OVERLOADABLE float convert_float_rtp(int x);
+OVERLOADABLE float convert_float_rtn(int x);
+OVERLOADABLE half convert_half_rte(int x);
+OVERLOADABLE half convert_half_rtz(int x);
+OVERLOADABLE half convert_half_rtp(int x);
+OVERLOADABLE half convert_half_rtn(int x);
+OVERLOADABLE long convert_long_rte(uint x);
+OVERLOADABLE long convert_long_rtz(uint x);
+OVERLOADABLE long convert_long_rtp(uint x);
+OVERLOADABLE long convert_long_rtn(uint x);
+OVERLOADABLE ulong convert_ulong_rte(uint x);
+OVERLOADABLE ulong convert_ulong_rtz(uint x);
+OVERLOADABLE ulong convert_ulong_rtp(uint x);
+OVERLOADABLE ulong convert_ulong_rtn(uint x);
+OVERLOADABLE int convert_int_rte(uint x);
+OVERLOADABLE int convert_int_rtz(uint x);
+OVERLOADABLE int convert_int_rtp(uint x);
+OVERLOADABLE int convert_int_rtn(uint x);
+OVERLOADABLE uint convert_uint_rte(uint x);
+OVERLOADABLE uint convert_uint_rtz(uint x);
+OVERLOADABLE uint convert_uint_rtp(uint x);
+OVERLOADABLE uint convert_uint_rtn(uint x);
+OVERLOADABLE short convert_short_rte(uint x);
+OVERLOADABLE short convert_short_rtz(uint x);
+OVERLOADABLE short convert_short_rtp(uint x);
+OVERLOADABLE short convert_short_rtn(uint x);
+OVERLOADABLE ushort convert_ushort_rte(uint x);
+OVERLOADABLE ushort convert_ushort_rtz(uint x);
+OVERLOADABLE ushort convert_ushort_rtp(uint x);
+OVERLOADABLE ushort convert_ushort_rtn(uint x);
+OVERLOADABLE char convert_char_rte(uint x);
+OVERLOADABLE char convert_char_rtz(uint x);
+OVERLOADABLE char convert_char_rtp(uint x);
+OVERLOADABLE char convert_char_rtn(uint x);
+OVERLOADABLE uchar convert_uchar_rte(uint x);
+OVERLOADABLE uchar convert_uchar_rtz(uint x);
+OVERLOADABLE uchar convert_uchar_rtp(uint x);
+OVERLOADABLE uchar convert_uchar_rtn(uint x);
+OVERLOADABLE float convert_float_rte(uint x);
+OVERLOADABLE float convert_float_rtz(uint x);
+OVERLOADABLE float convert_float_rtp(uint x);
+OVERLOADABLE float convert_float_rtn(uint x);
+OVERLOADABLE half convert_half_rte(uint x);
+OVERLOADABLE half convert_half_rtz(uint x);
+OVERLOADABLE half convert_half_rtp(uint x);
+OVERLOADABLE half convert_half_rtn(uint x);
+OVERLOADABLE long convert_long_rte(short x);
+OVERLOADABLE long convert_long_rtz(short x);
+OVERLOADABLE long convert_long_rtp(short x);
+OVERLOADABLE long convert_long_rtn(short x);
+OVERLOADABLE ulong convert_ulong_rte(short x);
+OVERLOADABLE ulong convert_ulong_rtz(short x);
+OVERLOADABLE ulong convert_ulong_rtp(short x);
+OVERLOADABLE ulong convert_ulong_rtn(short x);
+OVERLOADABLE int convert_int_rte(short x);
+OVERLOADABLE int convert_int_rtz(short x);
+OVERLOADABLE int convert_int_rtp(short x);
+OVERLOADABLE int convert_int_rtn(short x);
+OVERLOADABLE uint convert_uint_rte(short x);
+OVERLOADABLE uint convert_uint_rtz(short x);
+OVERLOADABLE uint convert_uint_rtp(short x);
+OVERLOADABLE uint convert_uint_rtn(short x);
+OVERLOADABLE short convert_short_rte(short x);
+OVERLOADABLE short convert_short_rtz(short x);
+OVERLOADABLE short convert_short_rtp(short x);
+OVERLOADABLE short convert_short_rtn(short x);
+OVERLOADABLE ushort convert_ushort_rte(short x);
+OVERLOADABLE ushort convert_ushort_rtz(short x);
+OVERLOADABLE ushort convert_ushort_rtp(short x);
+OVERLOADABLE ushort convert_ushort_rtn(short x);
+OVERLOADABLE char convert_char_rte(short x);
+OVERLOADABLE char convert_char_rtz(short x);
+OVERLOADABLE char convert_char_rtp(short x);
+OVERLOADABLE char convert_char_rtn(short x);
+OVERLOADABLE uchar convert_uchar_rte(short x);
+OVERLOADABLE uchar convert_uchar_rtz(short x);
+OVERLOADABLE uchar convert_uchar_rtp(short x);
+OVERLOADABLE uchar convert_uchar_rtn(short x);
+OVERLOADABLE float convert_float_rte(short x);
+OVERLOADABLE float convert_float_rtz(short x);
+OVERLOADABLE float convert_float_rtp(short x);
+OVERLOADABLE float convert_float_rtn(short x);
+OVERLOADABLE half convert_half_rte(short x);
+OVERLOADABLE half convert_half_rtz(short x);
+OVERLOADABLE half convert_half_rtp(short x);
+OVERLOADABLE half convert_half_rtn(short x);
+OVERLOADABLE long convert_long_rte(ushort x);
+OVERLOADABLE long convert_long_rtz(ushort x);
+OVERLOADABLE long convert_long_rtp(ushort x);
+OVERLOADABLE long convert_long_rtn(ushort x);
+OVERLOADABLE ulong convert_ulong_rte(ushort x);
+OVERLOADABLE ulong convert_ulong_rtz(ushort x);
+OVERLOADABLE ulong convert_ulong_rtp(ushort x);
+OVERLOADABLE ulong convert_ulong_rtn(ushort x);
+OVERLOADABLE int convert_int_rte(ushort x);
+OVERLOADABLE int convert_int_rtz(ushort x);
+OVERLOADABLE int convert_int_rtp(ushort x);
+OVERLOADABLE int convert_int_rtn(ushort x);
+OVERLOADABLE uint convert_uint_rte(ushort x);
+OVERLOADABLE uint convert_uint_rtz(ushort x);
+OVERLOADABLE uint convert_uint_rtp(ushort x);
+OVERLOADABLE uint convert_uint_rtn(ushort x);
+OVERLOADABLE short convert_short_rte(ushort x);
+OVERLOADABLE short convert_short_rtz(ushort x);
+OVERLOADABLE short convert_short_rtp(ushort x);
+OVERLOADABLE short convert_short_rtn(ushort x);
+OVERLOADABLE ushort convert_ushort_rte(ushort x);
+OVERLOADABLE ushort convert_ushort_rtz(ushort x);
+OVERLOADABLE ushort convert_ushort_rtp(ushort x);
+OVERLOADABLE ushort convert_ushort_rtn(ushort x);
+OVERLOADABLE char convert_char_rte(ushort x);
+OVERLOADABLE char convert_char_rtz(ushort x);
+OVERLOADABLE char convert_char_rtp(ushort x);
+OVERLOADABLE char convert_char_rtn(ushort x);
+OVERLOADABLE uchar convert_uchar_rte(ushort x);
+OVERLOADABLE uchar convert_uchar_rtz(ushort x);
+OVERLOADABLE uchar convert_uchar_rtp(ushort x);
+OVERLOADABLE uchar convert_uchar_rtn(ushort x);
+OVERLOADABLE float convert_float_rte(ushort x);
+OVERLOADABLE float convert_float_rtz(ushort x);
+OVERLOADABLE float convert_float_rtp(ushort x);
+OVERLOADABLE float convert_float_rtn(ushort x);
+OVERLOADABLE half convert_half_rte(ushort x);
+OVERLOADABLE half convert_half_rtz(ushort x);
+OVERLOADABLE half convert_half_rtp(ushort x);
+OVERLOADABLE half convert_half_rtn(ushort x);
+OVERLOADABLE long convert_long_rte(char x);
+OVERLOADABLE long convert_long_rtz(char x);
+OVERLOADABLE long convert_long_rtp(char x);
+OVERLOADABLE long convert_long_rtn(char x);
+OVERLOADABLE ulong convert_ulong_rte(char x);
+OVERLOADABLE ulong convert_ulong_rtz(char x);
+OVERLOADABLE ulong convert_ulong_rtp(char x);
+OVERLOADABLE ulong convert_ulong_rtn(char x);
+OVERLOADABLE int convert_int_rte(char x);
+OVERLOADABLE int convert_int_rtz(char x);
+OVERLOADABLE int convert_int_rtp(char x);
+OVERLOADABLE int convert_int_rtn(char x);
+OVERLOADABLE uint convert_uint_rte(char x);
+OVERLOADABLE uint convert_uint_rtz(char x);
+OVERLOADABLE uint convert_uint_rtp(char x);
+OVERLOADABLE uint convert_uint_rtn(char x);
+OVERLOADABLE short convert_short_rte(char x);
+OVERLOADABLE short convert_short_rtz(char x);
+OVERLOADABLE short convert_short_rtp(char x);
+OVERLOADABLE short convert_short_rtn(char x);
+OVERLOADABLE ushort convert_ushort_rte(char x);
+OVERLOADABLE ushort convert_ushort_rtz(char x);
+OVERLOADABLE ushort convert_ushort_rtp(char x);
+OVERLOADABLE ushort convert_ushort_rtn(char x);
+OVERLOADABLE char convert_char_rte(char x);
+OVERLOADABLE char convert_char_rtz(char x);
+OVERLOADABLE char convert_char_rtp(char x);
+OVERLOADABLE char convert_char_rtn(char x);
+OVERLOADABLE uchar convert_uchar_rte(char x);
+OVERLOADABLE uchar convert_uchar_rtz(char x);
+OVERLOADABLE uchar convert_uchar_rtp(char x);
+OVERLOADABLE uchar convert_uchar_rtn(char x);
+OVERLOADABLE float convert_float_rte(char x);
+OVERLOADABLE float convert_float_rtz(char x);
+OVERLOADABLE float convert_float_rtp(char x);
+OVERLOADABLE float convert_float_rtn(char x);
+OVERLOADABLE half convert_half_rte(char x);
+OVERLOADABLE half convert_half_rtz(char x);
+OVERLOADABLE half convert_half_rtp(char x);
+OVERLOADABLE half convert_half_rtn(char x);
+OVERLOADABLE long convert_long_rte(uchar x);
+OVERLOADABLE long convert_long_rtz(uchar x);
+OVERLOADABLE long convert_long_rtp(uchar x);
+OVERLOADABLE long convert_long_rtn(uchar x);
+OVERLOADABLE ulong convert_ulong_rte(uchar x);
+OVERLOADABLE ulong convert_ulong_rtz(uchar x);
+OVERLOADABLE ulong convert_ulong_rtp(uchar x);
+OVERLOADABLE ulong convert_ulong_rtn(uchar x);
+OVERLOADABLE int convert_int_rte(uchar x);
+OVERLOADABLE int convert_int_rtz(uchar x);
+OVERLOADABLE int convert_int_rtp(uchar x);
+OVERLOADABLE int convert_int_rtn(uchar x);
+OVERLOADABLE uint convert_uint_rte(uchar x);
+OVERLOADABLE uint convert_uint_rtz(uchar x);
+OVERLOADABLE uint convert_uint_rtp(uchar x);
+OVERLOADABLE uint convert_uint_rtn(uchar x);
+OVERLOADABLE short convert_short_rte(uchar x);
+OVERLOADABLE short convert_short_rtz(uchar x);
+OVERLOADABLE short convert_short_rtp(uchar x);
+OVERLOADABLE short convert_short_rtn(uchar x);
+OVERLOADABLE ushort convert_ushort_rte(uchar x);
+OVERLOADABLE ushort convert_ushort_rtz(uchar x);
+OVERLOADABLE ushort convert_ushort_rtp(uchar x);
+OVERLOADABLE ushort convert_ushort_rtn(uchar x);
+OVERLOADABLE char convert_char_rte(uchar x);
+OVERLOADABLE char convert_char_rtz(uchar x);
+OVERLOADABLE char convert_char_rtp(uchar x);
+OVERLOADABLE char convert_char_rtn(uchar x);
+OVERLOADABLE uchar convert_uchar_rte(uchar x);
+OVERLOADABLE uchar convert_uchar_rtz(uchar x);
+OVERLOADABLE uchar convert_uchar_rtp(uchar x);
+OVERLOADABLE uchar convert_uchar_rtn(uchar x);
+OVERLOADABLE float convert_float_rte(uchar x);
+OVERLOADABLE float convert_float_rtz(uchar x);
+OVERLOADABLE float convert_float_rtp(uchar x);
+OVERLOADABLE float convert_float_rtn(uchar x);
+OVERLOADABLE half convert_half_rte(uchar x);
+OVERLOADABLE half convert_half_rtz(uchar x);
+OVERLOADABLE half convert_half_rtp(uchar x);
+OVERLOADABLE half convert_half_rtn(uchar x);
+OVERLOADABLE long convert_long_rte(double x);
+OVERLOADABLE long convert_long_rtz(double x);
+OVERLOADABLE long convert_long_rtp(double x);
+OVERLOADABLE long convert_long_rtn(double x);
+OVERLOADABLE ulong convert_ulong_rte(double x);
+OVERLOADABLE ulong convert_ulong_rtz(double x);
+OVERLOADABLE ulong convert_ulong_rtp(double x);
+OVERLOADABLE ulong convert_ulong_rtn(double x);
+OVERLOADABLE int convert_int_rte(double x);
+OVERLOADABLE int convert_int_rtz(double x);
+OVERLOADABLE int convert_int_rtp(double x);
+OVERLOADABLE int convert_int_rtn(double x);
+OVERLOADABLE uint convert_uint_rte(double x);
+OVERLOADABLE uint convert_uint_rtz(double x);
+OVERLOADABLE uint convert_uint_rtp(double x);
+OVERLOADABLE uint convert_uint_rtn(double x);
+OVERLOADABLE short convert_short_rte(double x);
+OVERLOADABLE short convert_short_rtz(double x);
+OVERLOADABLE short convert_short_rtp(double x);
+OVERLOADABLE short convert_short_rtn(double x);
+OVERLOADABLE ushort convert_ushort_rte(double x);
+OVERLOADABLE ushort convert_ushort_rtz(double x);
+OVERLOADABLE ushort convert_ushort_rtp(double x);
+OVERLOADABLE ushort convert_ushort_rtn(double x);
+OVERLOADABLE char convert_char_rte(double x);
+OVERLOADABLE char convert_char_rtz(double x);
+OVERLOADABLE char convert_char_rtp(double x);
+OVERLOADABLE char convert_char_rtn(double x);
+OVERLOADABLE uchar convert_uchar_rte(double x);
+OVERLOADABLE uchar convert_uchar_rtz(double x);
+OVERLOADABLE uchar convert_uchar_rtp(double x);
+OVERLOADABLE uchar convert_uchar_rtn(double x);
+OVERLOADABLE float convert_float_rte(double x);
+OVERLOADABLE float convert_float_rtz(double x);
+OVERLOADABLE float convert_float_rtp(double x);
+OVERLOADABLE float convert_float_rtn(double x);
+OVERLOADABLE half convert_half_rte(double x);
+OVERLOADABLE half convert_half_rtz(double x);
+OVERLOADABLE half convert_half_rtp(double x);
+OVERLOADABLE half convert_half_rtn(double x);
+OVERLOADABLE long convert_long_rte(float x);
+OVERLOADABLE long convert_long_rtz(float x);
+OVERLOADABLE long convert_long_rtp(float x);
+OVERLOADABLE long convert_long_rtn(float x);
+OVERLOADABLE ulong convert_ulong_rte(float x);
+OVERLOADABLE ulong convert_ulong_rtz(float x);
+OVERLOADABLE ulong convert_ulong_rtp(float x);
+OVERLOADABLE ulong convert_ulong_rtn(float x);
+OVERLOADABLE int convert_int_rte(float x);
+OVERLOADABLE int convert_int_rtz(float x);
+OVERLOADABLE int convert_int_rtp(float x);
+OVERLOADABLE int convert_int_rtn(float x);
+OVERLOADABLE uint convert_uint_rte(float x);
+OVERLOADABLE uint convert_uint_rtz(float x);
+OVERLOADABLE uint convert_uint_rtp(float x);
+OVERLOADABLE uint convert_uint_rtn(float x);
+OVERLOADABLE short convert_short_rte(float x);
+OVERLOADABLE short convert_short_rtz(float x);
+OVERLOADABLE short convert_short_rtp(float x);
+OVERLOADABLE short convert_short_rtn(float x);
+OVERLOADABLE ushort convert_ushort_rte(float x);
+OVERLOADABLE ushort convert_ushort_rtz(float x);
+OVERLOADABLE ushort convert_ushort_rtp(float x);
+OVERLOADABLE ushort convert_ushort_rtn(float x);
+OVERLOADABLE char convert_char_rte(float x);
+OVERLOADABLE char convert_char_rtz(float x);
+OVERLOADABLE char convert_char_rtp(float x);
+OVERLOADABLE char convert_char_rtn(float x);
+OVERLOADABLE uchar convert_uchar_rte(float x);
+OVERLOADABLE uchar convert_uchar_rtz(float x);
+OVERLOADABLE uchar convert_uchar_rtp(float x);
+OVERLOADABLE uchar convert_uchar_rtn(float x);
+OVERLOADABLE float convert_float_rte(float x);
+OVERLOADABLE float convert_float_rtz(float x);
+OVERLOADABLE float convert_float_rtp(float x);
+OVERLOADABLE float convert_float_rtn(float x);
+OVERLOADABLE half convert_half_rte(float x);
+OVERLOADABLE half convert_half_rtz(float x);
+OVERLOADABLE half convert_half_rtp(float x);
+OVERLOADABLE half convert_half_rtn(float x);
+OVERLOADABLE long convert_long_rte(half x);
+OVERLOADABLE long convert_long_rtz(half x);
+OVERLOADABLE long convert_long_rtp(half x);
+OVERLOADABLE long convert_long_rtn(half x);
+OVERLOADABLE ulong convert_ulong_rte(half x);
+OVERLOADABLE ulong convert_ulong_rtz(half x);
+OVERLOADABLE ulong convert_ulong_rtp(half x);
+OVERLOADABLE ulong convert_ulong_rtn(half x);
+OVERLOADABLE int convert_int_rte(half x);
+OVERLOADABLE int convert_int_rtz(half x);
+OVERLOADABLE int convert_int_rtp(half x);
+OVERLOADABLE int convert_int_rtn(half x);
+OVERLOADABLE uint convert_uint_rte(half x);
+OVERLOADABLE uint convert_uint_rtz(half x);
+OVERLOADABLE uint convert_uint_rtp(half x);
+OVERLOADABLE uint convert_uint_rtn(half x);
+OVERLOADABLE short convert_short_rte(half x);
+OVERLOADABLE short convert_short_rtz(half x);
+OVERLOADABLE short convert_short_rtp(half x);
+OVERLOADABLE short convert_short_rtn(half x);
+OVERLOADABLE ushort convert_ushort_rte(half x);
+OVERLOADABLE ushort convert_ushort_rtz(half x);
+OVERLOADABLE ushort convert_ushort_rtp(half x);
+OVERLOADABLE ushort convert_ushort_rtn(half x);
+OVERLOADABLE char convert_char_rte(half x);
+OVERLOADABLE char convert_char_rtz(half x);
+OVERLOADABLE char convert_char_rtp(half x);
+OVERLOADABLE char convert_char_rtn(half x);
+OVERLOADABLE uchar convert_uchar_rte(half x);
+OVERLOADABLE uchar convert_uchar_rtz(half x);
+OVERLOADABLE uchar convert_uchar_rtp(half x);
+OVERLOADABLE uchar convert_uchar_rtn(half x);
+OVERLOADABLE float convert_float_rte(half x);
+OVERLOADABLE float convert_float_rtz(half x);
+OVERLOADABLE float convert_float_rtp(half x);
+OVERLOADABLE float convert_float_rtn(half x);
+OVERLOADABLE half convert_half_rte(half x);
+OVERLOADABLE half convert_half_rtz(half x);
+OVERLOADABLE half convert_half_rtp(half x);
+OVERLOADABLE half convert_half_rtn(half x);
+OVERLOADABLE long2 convert_long2_rte(long2 v);
+OVERLOADABLE long2 convert_long2_rtz(long2 v);
+OVERLOADABLE long2 convert_long2_rtp(long2 v);
+OVERLOADABLE long2 convert_long2_rtn(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(long2 v);
+OVERLOADABLE int2 convert_int2_rte(long2 v);
+OVERLOADABLE int2 convert_int2_rtz(long2 v);
+OVERLOADABLE int2 convert_int2_rtp(long2 v);
+OVERLOADABLE int2 convert_int2_rtn(long2 v);
+OVERLOADABLE uint2 convert_uint2_rte(long2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(long2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(long2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(long2 v);
+OVERLOADABLE short2 convert_short2_rte(long2 v);
+OVERLOADABLE short2 convert_short2_rtz(long2 v);
+OVERLOADABLE short2 convert_short2_rtp(long2 v);
+OVERLOADABLE short2 convert_short2_rtn(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(long2 v);
+OVERLOADABLE char2 convert_char2_rte(long2 v);
+OVERLOADABLE char2 convert_char2_rtz(long2 v);
+OVERLOADABLE char2 convert_char2_rtp(long2 v);
+OVERLOADABLE char2 convert_char2_rtn(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(long2 v);
+OVERLOADABLE float2 convert_float2_rte(long2 v);
+OVERLOADABLE float2 convert_float2_rtz(long2 v);
+OVERLOADABLE float2 convert_float2_rtp(long2 v);
+OVERLOADABLE float2 convert_float2_rtn(long2 v);
+OVERLOADABLE half2 convert_half2_rte(long2 v);
+OVERLOADABLE half2 convert_half2_rtz(long2 v);
+OVERLOADABLE half2 convert_half2_rtp(long2 v);
+OVERLOADABLE half2 convert_half2_rtn(long2 v);
+OVERLOADABLE long2 convert_long2_rte(ulong2 v);
+OVERLOADABLE long2 convert_long2_rtz(ulong2 v);
+OVERLOADABLE long2 convert_long2_rtp(ulong2 v);
+OVERLOADABLE long2 convert_long2_rtn(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(ulong2 v);
+OVERLOADABLE int2 convert_int2_rte(ulong2 v);
+OVERLOADABLE int2 convert_int2_rtz(ulong2 v);
+OVERLOADABLE int2 convert_int2_rtp(ulong2 v);
+OVERLOADABLE int2 convert_int2_rtn(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_rte(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(ulong2 v);
+OVERLOADABLE short2 convert_short2_rte(ulong2 v);
+OVERLOADABLE short2 convert_short2_rtz(ulong2 v);
+OVERLOADABLE short2 convert_short2_rtp(ulong2 v);
+OVERLOADABLE short2 convert_short2_rtn(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(ulong2 v);
+OVERLOADABLE char2 convert_char2_rte(ulong2 v);
+OVERLOADABLE char2 convert_char2_rtz(ulong2 v);
+OVERLOADABLE char2 convert_char2_rtp(ulong2 v);
+OVERLOADABLE char2 convert_char2_rtn(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(ulong2 v);
+OVERLOADABLE float2 convert_float2_rte(ulong2 v);
+OVERLOADABLE float2 convert_float2_rtz(ulong2 v);
+OVERLOADABLE float2 convert_float2_rtp(ulong2 v);
+OVERLOADABLE float2 convert_float2_rtn(ulong2 v);
+OVERLOADABLE half2 convert_half2_rte(ulong2 v);
+OVERLOADABLE half2 convert_half2_rtz(ulong2 v);
+OVERLOADABLE half2 convert_half2_rtp(ulong2 v);
+OVERLOADABLE half2 convert_half2_rtn(ulong2 v);
+OVERLOADABLE long2 convert_long2_rte(int2 v);
+OVERLOADABLE long2 convert_long2_rtz(int2 v);
+OVERLOADABLE long2 convert_long2_rtp(int2 v);
+OVERLOADABLE long2 convert_long2_rtn(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(int2 v);
+OVERLOADABLE int2 convert_int2_rte(int2 v);
+OVERLOADABLE int2 convert_int2_rtz(int2 v);
+OVERLOADABLE int2 convert_int2_rtp(int2 v);
+OVERLOADABLE int2 convert_int2_rtn(int2 v);
+OVERLOADABLE uint2 convert_uint2_rte(int2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(int2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(int2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(int2 v);
+OVERLOADABLE short2 convert_short2_rte(int2 v);
+OVERLOADABLE short2 convert_short2_rtz(int2 v);
+OVERLOADABLE short2 convert_short2_rtp(int2 v);
+OVERLOADABLE short2 convert_short2_rtn(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(int2 v);
+OVERLOADABLE char2 convert_char2_rte(int2 v);
+OVERLOADABLE char2 convert_char2_rtz(int2 v);
+OVERLOADABLE char2 convert_char2_rtp(int2 v);
+OVERLOADABLE char2 convert_char2_rtn(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(int2 v);
+OVERLOADABLE float2 convert_float2_rte(int2 v);
+OVERLOADABLE float2 convert_float2_rtz(int2 v);
+OVERLOADABLE float2 convert_float2_rtp(int2 v);
+OVERLOADABLE float2 convert_float2_rtn(int2 v);
+OVERLOADABLE half2 convert_half2_rte(int2 v);
+OVERLOADABLE half2 convert_half2_rtz(int2 v);
+OVERLOADABLE half2 convert_half2_rtp(int2 v);
+OVERLOADABLE half2 convert_half2_rtn(int2 v);
+OVERLOADABLE long2 convert_long2_rte(uint2 v);
+OVERLOADABLE long2 convert_long2_rtz(uint2 v);
+OVERLOADABLE long2 convert_long2_rtp(uint2 v);
+OVERLOADABLE long2 convert_long2_rtn(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(uint2 v);
+OVERLOADABLE int2 convert_int2_rte(uint2 v);
+OVERLOADABLE int2 convert_int2_rtz(uint2 v);
+OVERLOADABLE int2 convert_int2_rtp(uint2 v);
+OVERLOADABLE int2 convert_int2_rtn(uint2 v);
+OVERLOADABLE uint2 convert_uint2_rte(uint2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(uint2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(uint2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(uint2 v);
+OVERLOADABLE short2 convert_short2_rte(uint2 v);
+OVERLOADABLE short2 convert_short2_rtz(uint2 v);
+OVERLOADABLE short2 convert_short2_rtp(uint2 v);
+OVERLOADABLE short2 convert_short2_rtn(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(uint2 v);
+OVERLOADABLE char2 convert_char2_rte(uint2 v);
+OVERLOADABLE char2 convert_char2_rtz(uint2 v);
+OVERLOADABLE char2 convert_char2_rtp(uint2 v);
+OVERLOADABLE char2 convert_char2_rtn(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(uint2 v);
+OVERLOADABLE float2 convert_float2_rte(uint2 v);
+OVERLOADABLE float2 convert_float2_rtz(uint2 v);
+OVERLOADABLE float2 convert_float2_rtp(uint2 v);
+OVERLOADABLE float2 convert_float2_rtn(uint2 v);
+OVERLOADABLE half2 convert_half2_rte(uint2 v);
+OVERLOADABLE half2 convert_half2_rtz(uint2 v);
+OVERLOADABLE half2 convert_half2_rtp(uint2 v);
+OVERLOADABLE half2 convert_half2_rtn(uint2 v);
+OVERLOADABLE long2 convert_long2_rte(short2 v);
+OVERLOADABLE long2 convert_long2_rtz(short2 v);
+OVERLOADABLE long2 convert_long2_rtp(short2 v);
+OVERLOADABLE long2 convert_long2_rtn(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(short2 v);
+OVERLOADABLE int2 convert_int2_rte(short2 v);
+OVERLOADABLE int2 convert_int2_rtz(short2 v);
+OVERLOADABLE int2 convert_int2_rtp(short2 v);
+OVERLOADABLE int2 convert_int2_rtn(short2 v);
+OVERLOADABLE uint2 convert_uint2_rte(short2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(short2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(short2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(short2 v);
+OVERLOADABLE short2 convert_short2_rte(short2 v);
+OVERLOADABLE short2 convert_short2_rtz(short2 v);
+OVERLOADABLE short2 convert_short2_rtp(short2 v);
+OVERLOADABLE short2 convert_short2_rtn(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(short2 v);
+OVERLOADABLE char2 convert_char2_rte(short2 v);
+OVERLOADABLE char2 convert_char2_rtz(short2 v);
+OVERLOADABLE char2 convert_char2_rtp(short2 v);
+OVERLOADABLE char2 convert_char2_rtn(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(short2 v);
+OVERLOADABLE float2 convert_float2_rte(short2 v);
+OVERLOADABLE float2 convert_float2_rtz(short2 v);
+OVERLOADABLE float2 convert_float2_rtp(short2 v);
+OVERLOADABLE float2 convert_float2_rtn(short2 v);
+OVERLOADABLE half2 convert_half2_rte(short2 v);
+OVERLOADABLE half2 convert_half2_rtz(short2 v);
+OVERLOADABLE half2 convert_half2_rtp(short2 v);
+OVERLOADABLE half2 convert_half2_rtn(short2 v);
+OVERLOADABLE long2 convert_long2_rte(ushort2 v);
+OVERLOADABLE long2 convert_long2_rtz(ushort2 v);
+OVERLOADABLE long2 convert_long2_rtp(ushort2 v);
+OVERLOADABLE long2 convert_long2_rtn(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(ushort2 v);
+OVERLOADABLE int2 convert_int2_rte(ushort2 v);
+OVERLOADABLE int2 convert_int2_rtz(ushort2 v);
+OVERLOADABLE int2 convert_int2_rtp(ushort2 v);
+OVERLOADABLE int2 convert_int2_rtn(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_rte(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(ushort2 v);
+OVERLOADABLE short2 convert_short2_rte(ushort2 v);
+OVERLOADABLE short2 convert_short2_rtz(ushort2 v);
+OVERLOADABLE short2 convert_short2_rtp(ushort2 v);
+OVERLOADABLE short2 convert_short2_rtn(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(ushort2 v);
+OVERLOADABLE char2 convert_char2_rte(ushort2 v);
+OVERLOADABLE char2 convert_char2_rtz(ushort2 v);
+OVERLOADABLE char2 convert_char2_rtp(ushort2 v);
+OVERLOADABLE char2 convert_char2_rtn(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(ushort2 v);
+OVERLOADABLE float2 convert_float2_rte(ushort2 v);
+OVERLOADABLE float2 convert_float2_rtz(ushort2 v);
+OVERLOADABLE float2 convert_float2_rtp(ushort2 v);
+OVERLOADABLE float2 convert_float2_rtn(ushort2 v);
+OVERLOADABLE half2 convert_half2_rte(ushort2 v);
+OVERLOADABLE half2 convert_half2_rtz(ushort2 v);
+OVERLOADABLE half2 convert_half2_rtp(ushort2 v);
+OVERLOADABLE half2 convert_half2_rtn(ushort2 v);
+OVERLOADABLE long2 convert_long2_rte(char2 v);
+OVERLOADABLE long2 convert_long2_rtz(char2 v);
+OVERLOADABLE long2 convert_long2_rtp(char2 v);
+OVERLOADABLE long2 convert_long2_rtn(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(char2 v);
+OVERLOADABLE int2 convert_int2_rte(char2 v);
+OVERLOADABLE int2 convert_int2_rtz(char2 v);
+OVERLOADABLE int2 convert_int2_rtp(char2 v);
+OVERLOADABLE int2 convert_int2_rtn(char2 v);
+OVERLOADABLE uint2 convert_uint2_rte(char2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(char2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(char2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(char2 v);
+OVERLOADABLE short2 convert_short2_rte(char2 v);
+OVERLOADABLE short2 convert_short2_rtz(char2 v);
+OVERLOADABLE short2 convert_short2_rtp(char2 v);
+OVERLOADABLE short2 convert_short2_rtn(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(char2 v);
+OVERLOADABLE char2 convert_char2_rte(char2 v);
+OVERLOADABLE char2 convert_char2_rtz(char2 v);
+OVERLOADABLE char2 convert_char2_rtp(char2 v);
+OVERLOADABLE char2 convert_char2_rtn(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(char2 v);
+OVERLOADABLE float2 convert_float2_rte(char2 v);
+OVERLOADABLE float2 convert_float2_rtz(char2 v);
+OVERLOADABLE float2 convert_float2_rtp(char2 v);
+OVERLOADABLE float2 convert_float2_rtn(char2 v);
+OVERLOADABLE half2 convert_half2_rte(char2 v);
+OVERLOADABLE half2 convert_half2_rtz(char2 v);
+OVERLOADABLE half2 convert_half2_rtp(char2 v);
+OVERLOADABLE half2 convert_half2_rtn(char2 v);
+OVERLOADABLE long2 convert_long2_rte(uchar2 v);
+OVERLOADABLE long2 convert_long2_rtz(uchar2 v);
+OVERLOADABLE long2 convert_long2_rtp(uchar2 v);
+OVERLOADABLE long2 convert_long2_rtn(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(uchar2 v);
+OVERLOADABLE int2 convert_int2_rte(uchar2 v);
+OVERLOADABLE int2 convert_int2_rtz(uchar2 v);
+OVERLOADABLE int2 convert_int2_rtp(uchar2 v);
+OVERLOADABLE int2 convert_int2_rtn(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_rte(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(uchar2 v);
+OVERLOADABLE short2 convert_short2_rte(uchar2 v);
+OVERLOADABLE short2 convert_short2_rtz(uchar2 v);
+OVERLOADABLE short2 convert_short2_rtp(uchar2 v);
+OVERLOADABLE short2 convert_short2_rtn(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(uchar2 v);
+OVERLOADABLE char2 convert_char2_rte(uchar2 v);
+OVERLOADABLE char2 convert_char2_rtz(uchar2 v);
+OVERLOADABLE char2 convert_char2_rtp(uchar2 v);
+OVERLOADABLE char2 convert_char2_rtn(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(uchar2 v);
+OVERLOADABLE float2 convert_float2_rte(uchar2 v);
+OVERLOADABLE float2 convert_float2_rtz(uchar2 v);
+OVERLOADABLE float2 convert_float2_rtp(uchar2 v);
+OVERLOADABLE float2 convert_float2_rtn(uchar2 v);
+OVERLOADABLE half2 convert_half2_rte(uchar2 v);
+OVERLOADABLE half2 convert_half2_rtz(uchar2 v);
+OVERLOADABLE half2 convert_half2_rtp(uchar2 v);
+OVERLOADABLE half2 convert_half2_rtn(uchar2 v);
+OVERLOADABLE long2 convert_long2_rte(double2 v);
+OVERLOADABLE long2 convert_long2_rtz(double2 v);
+OVERLOADABLE long2 convert_long2_rtp(double2 v);
+OVERLOADABLE long2 convert_long2_rtn(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(double2 v);
+OVERLOADABLE int2 convert_int2_rte(double2 v);
+OVERLOADABLE int2 convert_int2_rtz(double2 v);
+OVERLOADABLE int2 convert_int2_rtp(double2 v);
+OVERLOADABLE int2 convert_int2_rtn(double2 v);
+OVERLOADABLE uint2 convert_uint2_rte(double2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(double2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(double2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(double2 v);
+OVERLOADABLE short2 convert_short2_rte(double2 v);
+OVERLOADABLE short2 convert_short2_rtz(double2 v);
+OVERLOADABLE short2 convert_short2_rtp(double2 v);
+OVERLOADABLE short2 convert_short2_rtn(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(double2 v);
+OVERLOADABLE char2 convert_char2_rte(double2 v);
+OVERLOADABLE char2 convert_char2_rtz(double2 v);
+OVERLOADABLE char2 convert_char2_rtp(double2 v);
+OVERLOADABLE char2 convert_char2_rtn(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(double2 v);
+OVERLOADABLE float2 convert_float2_rte(double2 v);
+OVERLOADABLE float2 convert_float2_rtz(double2 v);
+OVERLOADABLE float2 convert_float2_rtp(double2 v);
+OVERLOADABLE float2 convert_float2_rtn(double2 v);
+OVERLOADABLE half2 convert_half2_rte(double2 v);
+OVERLOADABLE half2 convert_half2_rtz(double2 v);
+OVERLOADABLE half2 convert_half2_rtp(double2 v);
+OVERLOADABLE half2 convert_half2_rtn(double2 v);
+OVERLOADABLE long2 convert_long2_rte(float2 v);
+OVERLOADABLE long2 convert_long2_rtz(float2 v);
+OVERLOADABLE long2 convert_long2_rtp(float2 v);
+OVERLOADABLE long2 convert_long2_rtn(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(float2 v);
+OVERLOADABLE int2 convert_int2_rte(float2 v);
+OVERLOADABLE int2 convert_int2_rtz(float2 v);
+OVERLOADABLE int2 convert_int2_rtp(float2 v);
+OVERLOADABLE int2 convert_int2_rtn(float2 v);
+OVERLOADABLE uint2 convert_uint2_rte(float2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(float2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(float2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(float2 v);
+OVERLOADABLE short2 convert_short2_rte(float2 v);
+OVERLOADABLE short2 convert_short2_rtz(float2 v);
+OVERLOADABLE short2 convert_short2_rtp(float2 v);
+OVERLOADABLE short2 convert_short2_rtn(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(float2 v);
+OVERLOADABLE char2 convert_char2_rte(float2 v);
+OVERLOADABLE char2 convert_char2_rtz(float2 v);
+OVERLOADABLE char2 convert_char2_rtp(float2 v);
+OVERLOADABLE char2 convert_char2_rtn(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(float2 v);
+OVERLOADABLE float2 convert_float2_rte(float2 v);
+OVERLOADABLE float2 convert_float2_rtz(float2 v);
+OVERLOADABLE float2 convert_float2_rtp(float2 v);
+OVERLOADABLE float2 convert_float2_rtn(float2 v);
+OVERLOADABLE half2 convert_half2_rte(float2 v);
+OVERLOADABLE half2 convert_half2_rtz(float2 v);
+OVERLOADABLE half2 convert_half2_rtp(float2 v);
+OVERLOADABLE half2 convert_half2_rtn(float2 v);
+OVERLOADABLE long2 convert_long2_rte(half2 v);
+OVERLOADABLE long2 convert_long2_rtz(half2 v);
+OVERLOADABLE long2 convert_long2_rtp(half2 v);
+OVERLOADABLE long2 convert_long2_rtn(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_rte(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtz(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtp(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_rtn(half2 v);
+OVERLOADABLE int2 convert_int2_rte(half2 v);
+OVERLOADABLE int2 convert_int2_rtz(half2 v);
+OVERLOADABLE int2 convert_int2_rtp(half2 v);
+OVERLOADABLE int2 convert_int2_rtn(half2 v);
+OVERLOADABLE uint2 convert_uint2_rte(half2 v);
+OVERLOADABLE uint2 convert_uint2_rtz(half2 v);
+OVERLOADABLE uint2 convert_uint2_rtp(half2 v);
+OVERLOADABLE uint2 convert_uint2_rtn(half2 v);
+OVERLOADABLE short2 convert_short2_rte(half2 v);
+OVERLOADABLE short2 convert_short2_rtz(half2 v);
+OVERLOADABLE short2 convert_short2_rtp(half2 v);
+OVERLOADABLE short2 convert_short2_rtn(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_rte(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtz(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtp(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_rtn(half2 v);
+OVERLOADABLE char2 convert_char2_rte(half2 v);
+OVERLOADABLE char2 convert_char2_rtz(half2 v);
+OVERLOADABLE char2 convert_char2_rtp(half2 v);
+OVERLOADABLE char2 convert_char2_rtn(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_rte(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtz(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtp(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_rtn(half2 v);
+OVERLOADABLE float2 convert_float2_rte(half2 v);
+OVERLOADABLE float2 convert_float2_rtz(half2 v);
+OVERLOADABLE float2 convert_float2_rtp(half2 v);
+OVERLOADABLE float2 convert_float2_rtn(half2 v);
+OVERLOADABLE half2 convert_half2_rte(half2 v);
+OVERLOADABLE half2 convert_half2_rtz(half2 v);
+OVERLOADABLE half2 convert_half2_rtp(half2 v);
+OVERLOADABLE half2 convert_half2_rtn(half2 v);
+OVERLOADABLE long3 convert_long3_rte(long3 v);
+OVERLOADABLE long3 convert_long3_rtz(long3 v);
+OVERLOADABLE long3 convert_long3_rtp(long3 v);
+OVERLOADABLE long3 convert_long3_rtn(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(long3 v);
+OVERLOADABLE int3 convert_int3_rte(long3 v);
+OVERLOADABLE int3 convert_int3_rtz(long3 v);
+OVERLOADABLE int3 convert_int3_rtp(long3 v);
+OVERLOADABLE int3 convert_int3_rtn(long3 v);
+OVERLOADABLE uint3 convert_uint3_rte(long3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(long3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(long3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(long3 v);
+OVERLOADABLE short3 convert_short3_rte(long3 v);
+OVERLOADABLE short3 convert_short3_rtz(long3 v);
+OVERLOADABLE short3 convert_short3_rtp(long3 v);
+OVERLOADABLE short3 convert_short3_rtn(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(long3 v);
+OVERLOADABLE char3 convert_char3_rte(long3 v);
+OVERLOADABLE char3 convert_char3_rtz(long3 v);
+OVERLOADABLE char3 convert_char3_rtp(long3 v);
+OVERLOADABLE char3 convert_char3_rtn(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(long3 v);
+OVERLOADABLE float3 convert_float3_rte(long3 v);
+OVERLOADABLE float3 convert_float3_rtz(long3 v);
+OVERLOADABLE float3 convert_float3_rtp(long3 v);
+OVERLOADABLE float3 convert_float3_rtn(long3 v);
+OVERLOADABLE half3 convert_half3_rte(long3 v);
+OVERLOADABLE half3 convert_half3_rtz(long3 v);
+OVERLOADABLE half3 convert_half3_rtp(long3 v);
+OVERLOADABLE half3 convert_half3_rtn(long3 v);
+OVERLOADABLE long3 convert_long3_rte(ulong3 v);
+OVERLOADABLE long3 convert_long3_rtz(ulong3 v);
+OVERLOADABLE long3 convert_long3_rtp(ulong3 v);
+OVERLOADABLE long3 convert_long3_rtn(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(ulong3 v);
+OVERLOADABLE int3 convert_int3_rte(ulong3 v);
+OVERLOADABLE int3 convert_int3_rtz(ulong3 v);
+OVERLOADABLE int3 convert_int3_rtp(ulong3 v);
+OVERLOADABLE int3 convert_int3_rtn(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_rte(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(ulong3 v);
+OVERLOADABLE short3 convert_short3_rte(ulong3 v);
+OVERLOADABLE short3 convert_short3_rtz(ulong3 v);
+OVERLOADABLE short3 convert_short3_rtp(ulong3 v);
+OVERLOADABLE short3 convert_short3_rtn(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(ulong3 v);
+OVERLOADABLE char3 convert_char3_rte(ulong3 v);
+OVERLOADABLE char3 convert_char3_rtz(ulong3 v);
+OVERLOADABLE char3 convert_char3_rtp(ulong3 v);
+OVERLOADABLE char3 convert_char3_rtn(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(ulong3 v);
+OVERLOADABLE float3 convert_float3_rte(ulong3 v);
+OVERLOADABLE float3 convert_float3_rtz(ulong3 v);
+OVERLOADABLE float3 convert_float3_rtp(ulong3 v);
+OVERLOADABLE float3 convert_float3_rtn(ulong3 v);
+OVERLOADABLE half3 convert_half3_rte(ulong3 v);
+OVERLOADABLE half3 convert_half3_rtz(ulong3 v);
+OVERLOADABLE half3 convert_half3_rtp(ulong3 v);
+OVERLOADABLE half3 convert_half3_rtn(ulong3 v);
+OVERLOADABLE long3 convert_long3_rte(int3 v);
+OVERLOADABLE long3 convert_long3_rtz(int3 v);
+OVERLOADABLE long3 convert_long3_rtp(int3 v);
+OVERLOADABLE long3 convert_long3_rtn(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(int3 v);
+OVERLOADABLE int3 convert_int3_rte(int3 v);
+OVERLOADABLE int3 convert_int3_rtz(int3 v);
+OVERLOADABLE int3 convert_int3_rtp(int3 v);
+OVERLOADABLE int3 convert_int3_rtn(int3 v);
+OVERLOADABLE uint3 convert_uint3_rte(int3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(int3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(int3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(int3 v);
+OVERLOADABLE short3 convert_short3_rte(int3 v);
+OVERLOADABLE short3 convert_short3_rtz(int3 v);
+OVERLOADABLE short3 convert_short3_rtp(int3 v);
+OVERLOADABLE short3 convert_short3_rtn(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(int3 v);
+OVERLOADABLE char3 convert_char3_rte(int3 v);
+OVERLOADABLE char3 convert_char3_rtz(int3 v);
+OVERLOADABLE char3 convert_char3_rtp(int3 v);
+OVERLOADABLE char3 convert_char3_rtn(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(int3 v);
+OVERLOADABLE float3 convert_float3_rte(int3 v);
+OVERLOADABLE float3 convert_float3_rtz(int3 v);
+OVERLOADABLE float3 convert_float3_rtp(int3 v);
+OVERLOADABLE float3 convert_float3_rtn(int3 v);
+OVERLOADABLE half3 convert_half3_rte(int3 v);
+OVERLOADABLE half3 convert_half3_rtz(int3 v);
+OVERLOADABLE half3 convert_half3_rtp(int3 v);
+OVERLOADABLE half3 convert_half3_rtn(int3 v);
+OVERLOADABLE long3 convert_long3_rte(uint3 v);
+OVERLOADABLE long3 convert_long3_rtz(uint3 v);
+OVERLOADABLE long3 convert_long3_rtp(uint3 v);
+OVERLOADABLE long3 convert_long3_rtn(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(uint3 v);
+OVERLOADABLE int3 convert_int3_rte(uint3 v);
+OVERLOADABLE int3 convert_int3_rtz(uint3 v);
+OVERLOADABLE int3 convert_int3_rtp(uint3 v);
+OVERLOADABLE int3 convert_int3_rtn(uint3 v);
+OVERLOADABLE uint3 convert_uint3_rte(uint3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(uint3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(uint3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(uint3 v);
+OVERLOADABLE short3 convert_short3_rte(uint3 v);
+OVERLOADABLE short3 convert_short3_rtz(uint3 v);
+OVERLOADABLE short3 convert_short3_rtp(uint3 v);
+OVERLOADABLE short3 convert_short3_rtn(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(uint3 v);
+OVERLOADABLE char3 convert_char3_rte(uint3 v);
+OVERLOADABLE char3 convert_char3_rtz(uint3 v);
+OVERLOADABLE char3 convert_char3_rtp(uint3 v);
+OVERLOADABLE char3 convert_char3_rtn(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(uint3 v);
+OVERLOADABLE float3 convert_float3_rte(uint3 v);
+OVERLOADABLE float3 convert_float3_rtz(uint3 v);
+OVERLOADABLE float3 convert_float3_rtp(uint3 v);
+OVERLOADABLE float3 convert_float3_rtn(uint3 v);
+OVERLOADABLE half3 convert_half3_rte(uint3 v);
+OVERLOADABLE half3 convert_half3_rtz(uint3 v);
+OVERLOADABLE half3 convert_half3_rtp(uint3 v);
+OVERLOADABLE half3 convert_half3_rtn(uint3 v);
+OVERLOADABLE long3 convert_long3_rte(short3 v);
+OVERLOADABLE long3 convert_long3_rtz(short3 v);
+OVERLOADABLE long3 convert_long3_rtp(short3 v);
+OVERLOADABLE long3 convert_long3_rtn(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(short3 v);
+OVERLOADABLE int3 convert_int3_rte(short3 v);
+OVERLOADABLE int3 convert_int3_rtz(short3 v);
+OVERLOADABLE int3 convert_int3_rtp(short3 v);
+OVERLOADABLE int3 convert_int3_rtn(short3 v);
+OVERLOADABLE uint3 convert_uint3_rte(short3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(short3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(short3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(short3 v);
+OVERLOADABLE short3 convert_short3_rte(short3 v);
+OVERLOADABLE short3 convert_short3_rtz(short3 v);
+OVERLOADABLE short3 convert_short3_rtp(short3 v);
+OVERLOADABLE short3 convert_short3_rtn(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(short3 v);
+OVERLOADABLE char3 convert_char3_rte(short3 v);
+OVERLOADABLE char3 convert_char3_rtz(short3 v);
+OVERLOADABLE char3 convert_char3_rtp(short3 v);
+OVERLOADABLE char3 convert_char3_rtn(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(short3 v);
+OVERLOADABLE float3 convert_float3_rte(short3 v);
+OVERLOADABLE float3 convert_float3_rtz(short3 v);
+OVERLOADABLE float3 convert_float3_rtp(short3 v);
+OVERLOADABLE float3 convert_float3_rtn(short3 v);
+OVERLOADABLE half3 convert_half3_rte(short3 v);
+OVERLOADABLE half3 convert_half3_rtz(short3 v);
+OVERLOADABLE half3 convert_half3_rtp(short3 v);
+OVERLOADABLE half3 convert_half3_rtn(short3 v);
+OVERLOADABLE long3 convert_long3_rte(ushort3 v);
+OVERLOADABLE long3 convert_long3_rtz(ushort3 v);
+OVERLOADABLE long3 convert_long3_rtp(ushort3 v);
+OVERLOADABLE long3 convert_long3_rtn(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(ushort3 v);
+OVERLOADABLE int3 convert_int3_rte(ushort3 v);
+OVERLOADABLE int3 convert_int3_rtz(ushort3 v);
+OVERLOADABLE int3 convert_int3_rtp(ushort3 v);
+OVERLOADABLE int3 convert_int3_rtn(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_rte(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(ushort3 v);
+OVERLOADABLE short3 convert_short3_rte(ushort3 v);
+OVERLOADABLE short3 convert_short3_rtz(ushort3 v);
+OVERLOADABLE short3 convert_short3_rtp(ushort3 v);
+OVERLOADABLE short3 convert_short3_rtn(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(ushort3 v);
+OVERLOADABLE char3 convert_char3_rte(ushort3 v);
+OVERLOADABLE char3 convert_char3_rtz(ushort3 v);
+OVERLOADABLE char3 convert_char3_rtp(ushort3 v);
+OVERLOADABLE char3 convert_char3_rtn(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(ushort3 v);
+OVERLOADABLE float3 convert_float3_rte(ushort3 v);
+OVERLOADABLE float3 convert_float3_rtz(ushort3 v);
+OVERLOADABLE float3 convert_float3_rtp(ushort3 v);
+OVERLOADABLE float3 convert_float3_rtn(ushort3 v);
+OVERLOADABLE half3 convert_half3_rte(ushort3 v);
+OVERLOADABLE half3 convert_half3_rtz(ushort3 v);
+OVERLOADABLE half3 convert_half3_rtp(ushort3 v);
+OVERLOADABLE half3 convert_half3_rtn(ushort3 v);
+OVERLOADABLE long3 convert_long3_rte(char3 v);
+OVERLOADABLE long3 convert_long3_rtz(char3 v);
+OVERLOADABLE long3 convert_long3_rtp(char3 v);
+OVERLOADABLE long3 convert_long3_rtn(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(char3 v);
+OVERLOADABLE int3 convert_int3_rte(char3 v);
+OVERLOADABLE int3 convert_int3_rtz(char3 v);
+OVERLOADABLE int3 convert_int3_rtp(char3 v);
+OVERLOADABLE int3 convert_int3_rtn(char3 v);
+OVERLOADABLE uint3 convert_uint3_rte(char3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(char3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(char3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(char3 v);
+OVERLOADABLE short3 convert_short3_rte(char3 v);
+OVERLOADABLE short3 convert_short3_rtz(char3 v);
+OVERLOADABLE short3 convert_short3_rtp(char3 v);
+OVERLOADABLE short3 convert_short3_rtn(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(char3 v);
+OVERLOADABLE char3 convert_char3_rte(char3 v);
+OVERLOADABLE char3 convert_char3_rtz(char3 v);
+OVERLOADABLE char3 convert_char3_rtp(char3 v);
+OVERLOADABLE char3 convert_char3_rtn(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(char3 v);
+OVERLOADABLE float3 convert_float3_rte(char3 v);
+OVERLOADABLE float3 convert_float3_rtz(char3 v);
+OVERLOADABLE float3 convert_float3_rtp(char3 v);
+OVERLOADABLE float3 convert_float3_rtn(char3 v);
+OVERLOADABLE half3 convert_half3_rte(char3 v);
+OVERLOADABLE half3 convert_half3_rtz(char3 v);
+OVERLOADABLE half3 convert_half3_rtp(char3 v);
+OVERLOADABLE half3 convert_half3_rtn(char3 v);
+OVERLOADABLE long3 convert_long3_rte(uchar3 v);
+OVERLOADABLE long3 convert_long3_rtz(uchar3 v);
+OVERLOADABLE long3 convert_long3_rtp(uchar3 v);
+OVERLOADABLE long3 convert_long3_rtn(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(uchar3 v);
+OVERLOADABLE int3 convert_int3_rte(uchar3 v);
+OVERLOADABLE int3 convert_int3_rtz(uchar3 v);
+OVERLOADABLE int3 convert_int3_rtp(uchar3 v);
+OVERLOADABLE int3 convert_int3_rtn(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_rte(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(uchar3 v);
+OVERLOADABLE short3 convert_short3_rte(uchar3 v);
+OVERLOADABLE short3 convert_short3_rtz(uchar3 v);
+OVERLOADABLE short3 convert_short3_rtp(uchar3 v);
+OVERLOADABLE short3 convert_short3_rtn(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(uchar3 v);
+OVERLOADABLE char3 convert_char3_rte(uchar3 v);
+OVERLOADABLE char3 convert_char3_rtz(uchar3 v);
+OVERLOADABLE char3 convert_char3_rtp(uchar3 v);
+OVERLOADABLE char3 convert_char3_rtn(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(uchar3 v);
+OVERLOADABLE float3 convert_float3_rte(uchar3 v);
+OVERLOADABLE float3 convert_float3_rtz(uchar3 v);
+OVERLOADABLE float3 convert_float3_rtp(uchar3 v);
+OVERLOADABLE float3 convert_float3_rtn(uchar3 v);
+OVERLOADABLE half3 convert_half3_rte(uchar3 v);
+OVERLOADABLE half3 convert_half3_rtz(uchar3 v);
+OVERLOADABLE half3 convert_half3_rtp(uchar3 v);
+OVERLOADABLE half3 convert_half3_rtn(uchar3 v);
+OVERLOADABLE long3 convert_long3_rte(double3 v);
+OVERLOADABLE long3 convert_long3_rtz(double3 v);
+OVERLOADABLE long3 convert_long3_rtp(double3 v);
+OVERLOADABLE long3 convert_long3_rtn(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(double3 v);
+OVERLOADABLE int3 convert_int3_rte(double3 v);
+OVERLOADABLE int3 convert_int3_rtz(double3 v);
+OVERLOADABLE int3 convert_int3_rtp(double3 v);
+OVERLOADABLE int3 convert_int3_rtn(double3 v);
+OVERLOADABLE uint3 convert_uint3_rte(double3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(double3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(double3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(double3 v);
+OVERLOADABLE short3 convert_short3_rte(double3 v);
+OVERLOADABLE short3 convert_short3_rtz(double3 v);
+OVERLOADABLE short3 convert_short3_rtp(double3 v);
+OVERLOADABLE short3 convert_short3_rtn(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(double3 v);
+OVERLOADABLE char3 convert_char3_rte(double3 v);
+OVERLOADABLE char3 convert_char3_rtz(double3 v);
+OVERLOADABLE char3 convert_char3_rtp(double3 v);
+OVERLOADABLE char3 convert_char3_rtn(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(double3 v);
+OVERLOADABLE float3 convert_float3_rte(double3 v);
+OVERLOADABLE float3 convert_float3_rtz(double3 v);
+OVERLOADABLE float3 convert_float3_rtp(double3 v);
+OVERLOADABLE float3 convert_float3_rtn(double3 v);
+OVERLOADABLE half3 convert_half3_rte(double3 v);
+OVERLOADABLE half3 convert_half3_rtz(double3 v);
+OVERLOADABLE half3 convert_half3_rtp(double3 v);
+OVERLOADABLE half3 convert_half3_rtn(double3 v);
+OVERLOADABLE long3 convert_long3_rte(float3 v);
+OVERLOADABLE long3 convert_long3_rtz(float3 v);
+OVERLOADABLE long3 convert_long3_rtp(float3 v);
+OVERLOADABLE long3 convert_long3_rtn(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(float3 v);
+OVERLOADABLE int3 convert_int3_rte(float3 v);
+OVERLOADABLE int3 convert_int3_rtz(float3 v);
+OVERLOADABLE int3 convert_int3_rtp(float3 v);
+OVERLOADABLE int3 convert_int3_rtn(float3 v);
+OVERLOADABLE uint3 convert_uint3_rte(float3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(float3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(float3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(float3 v);
+OVERLOADABLE short3 convert_short3_rte(float3 v);
+OVERLOADABLE short3 convert_short3_rtz(float3 v);
+OVERLOADABLE short3 convert_short3_rtp(float3 v);
+OVERLOADABLE short3 convert_short3_rtn(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(float3 v);
+OVERLOADABLE char3 convert_char3_rte(float3 v);
+OVERLOADABLE char3 convert_char3_rtz(float3 v);
+OVERLOADABLE char3 convert_char3_rtp(float3 v);
+OVERLOADABLE char3 convert_char3_rtn(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(float3 v);
+OVERLOADABLE float3 convert_float3_rte(float3 v);
+OVERLOADABLE float3 convert_float3_rtz(float3 v);
+OVERLOADABLE float3 convert_float3_rtp(float3 v);
+OVERLOADABLE float3 convert_float3_rtn(float3 v);
+OVERLOADABLE half3 convert_half3_rte(float3 v);
+OVERLOADABLE half3 convert_half3_rtz(float3 v);
+OVERLOADABLE half3 convert_half3_rtp(float3 v);
+OVERLOADABLE half3 convert_half3_rtn(float3 v);
+OVERLOADABLE long3 convert_long3_rte(half3 v);
+OVERLOADABLE long3 convert_long3_rtz(half3 v);
+OVERLOADABLE long3 convert_long3_rtp(half3 v);
+OVERLOADABLE long3 convert_long3_rtn(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_rte(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtz(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtp(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_rtn(half3 v);
+OVERLOADABLE int3 convert_int3_rte(half3 v);
+OVERLOADABLE int3 convert_int3_rtz(half3 v);
+OVERLOADABLE int3 convert_int3_rtp(half3 v);
+OVERLOADABLE int3 convert_int3_rtn(half3 v);
+OVERLOADABLE uint3 convert_uint3_rte(half3 v);
+OVERLOADABLE uint3 convert_uint3_rtz(half3 v);
+OVERLOADABLE uint3 convert_uint3_rtp(half3 v);
+OVERLOADABLE uint3 convert_uint3_rtn(half3 v);
+OVERLOADABLE short3 convert_short3_rte(half3 v);
+OVERLOADABLE short3 convert_short3_rtz(half3 v);
+OVERLOADABLE short3 convert_short3_rtp(half3 v);
+OVERLOADABLE short3 convert_short3_rtn(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_rte(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtz(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtp(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_rtn(half3 v);
+OVERLOADABLE char3 convert_char3_rte(half3 v);
+OVERLOADABLE char3 convert_char3_rtz(half3 v);
+OVERLOADABLE char3 convert_char3_rtp(half3 v);
+OVERLOADABLE char3 convert_char3_rtn(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_rte(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtz(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtp(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_rtn(half3 v);
+OVERLOADABLE float3 convert_float3_rte(half3 v);
+OVERLOADABLE float3 convert_float3_rtz(half3 v);
+OVERLOADABLE float3 convert_float3_rtp(half3 v);
+OVERLOADABLE float3 convert_float3_rtn(half3 v);
+OVERLOADABLE half3 convert_half3_rte(half3 v);
+OVERLOADABLE half3 convert_half3_rtz(half3 v);
+OVERLOADABLE half3 convert_half3_rtp(half3 v);
+OVERLOADABLE half3 convert_half3_rtn(half3 v);
+OVERLOADABLE long4 convert_long4_rte(long4 v);
+OVERLOADABLE long4 convert_long4_rtz(long4 v);
+OVERLOADABLE long4 convert_long4_rtp(long4 v);
+OVERLOADABLE long4 convert_long4_rtn(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(long4 v);
+OVERLOADABLE int4 convert_int4_rte(long4 v);
+OVERLOADABLE int4 convert_int4_rtz(long4 v);
+OVERLOADABLE int4 convert_int4_rtp(long4 v);
+OVERLOADABLE int4 convert_int4_rtn(long4 v);
+OVERLOADABLE uint4 convert_uint4_rte(long4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(long4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(long4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(long4 v);
+OVERLOADABLE short4 convert_short4_rte(long4 v);
+OVERLOADABLE short4 convert_short4_rtz(long4 v);
+OVERLOADABLE short4 convert_short4_rtp(long4 v);
+OVERLOADABLE short4 convert_short4_rtn(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(long4 v);
+OVERLOADABLE char4 convert_char4_rte(long4 v);
+OVERLOADABLE char4 convert_char4_rtz(long4 v);
+OVERLOADABLE char4 convert_char4_rtp(long4 v);
+OVERLOADABLE char4 convert_char4_rtn(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(long4 v);
+OVERLOADABLE float4 convert_float4_rte(long4 v);
+OVERLOADABLE float4 convert_float4_rtz(long4 v);
+OVERLOADABLE float4 convert_float4_rtp(long4 v);
+OVERLOADABLE float4 convert_float4_rtn(long4 v);
+OVERLOADABLE half4 convert_half4_rte(long4 v);
+OVERLOADABLE half4 convert_half4_rtz(long4 v);
+OVERLOADABLE half4 convert_half4_rtp(long4 v);
+OVERLOADABLE half4 convert_half4_rtn(long4 v);
+OVERLOADABLE long4 convert_long4_rte(ulong4 v);
+OVERLOADABLE long4 convert_long4_rtz(ulong4 v);
+OVERLOADABLE long4 convert_long4_rtp(ulong4 v);
+OVERLOADABLE long4 convert_long4_rtn(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(ulong4 v);
+OVERLOADABLE int4 convert_int4_rte(ulong4 v);
+OVERLOADABLE int4 convert_int4_rtz(ulong4 v);
+OVERLOADABLE int4 convert_int4_rtp(ulong4 v);
+OVERLOADABLE int4 convert_int4_rtn(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_rte(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(ulong4 v);
+OVERLOADABLE short4 convert_short4_rte(ulong4 v);
+OVERLOADABLE short4 convert_short4_rtz(ulong4 v);
+OVERLOADABLE short4 convert_short4_rtp(ulong4 v);
+OVERLOADABLE short4 convert_short4_rtn(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(ulong4 v);
+OVERLOADABLE char4 convert_char4_rte(ulong4 v);
+OVERLOADABLE char4 convert_char4_rtz(ulong4 v);
+OVERLOADABLE char4 convert_char4_rtp(ulong4 v);
+OVERLOADABLE char4 convert_char4_rtn(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(ulong4 v);
+OVERLOADABLE float4 convert_float4_rte(ulong4 v);
+OVERLOADABLE float4 convert_float4_rtz(ulong4 v);
+OVERLOADABLE float4 convert_float4_rtp(ulong4 v);
+OVERLOADABLE float4 convert_float4_rtn(ulong4 v);
+OVERLOADABLE half4 convert_half4_rte(ulong4 v);
+OVERLOADABLE half4 convert_half4_rtz(ulong4 v);
+OVERLOADABLE half4 convert_half4_rtp(ulong4 v);
+OVERLOADABLE half4 convert_half4_rtn(ulong4 v);
+OVERLOADABLE long4 convert_long4_rte(int4 v);
+OVERLOADABLE long4 convert_long4_rtz(int4 v);
+OVERLOADABLE long4 convert_long4_rtp(int4 v);
+OVERLOADABLE long4 convert_long4_rtn(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(int4 v);
+OVERLOADABLE int4 convert_int4_rte(int4 v);
+OVERLOADABLE int4 convert_int4_rtz(int4 v);
+OVERLOADABLE int4 convert_int4_rtp(int4 v);
+OVERLOADABLE int4 convert_int4_rtn(int4 v);
+OVERLOADABLE uint4 convert_uint4_rte(int4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(int4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(int4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(int4 v);
+OVERLOADABLE short4 convert_short4_rte(int4 v);
+OVERLOADABLE short4 convert_short4_rtz(int4 v);
+OVERLOADABLE short4 convert_short4_rtp(int4 v);
+OVERLOADABLE short4 convert_short4_rtn(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(int4 v);
+OVERLOADABLE char4 convert_char4_rte(int4 v);
+OVERLOADABLE char4 convert_char4_rtz(int4 v);
+OVERLOADABLE char4 convert_char4_rtp(int4 v);
+OVERLOADABLE char4 convert_char4_rtn(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(int4 v);
+OVERLOADABLE float4 convert_float4_rte(int4 v);
+OVERLOADABLE float4 convert_float4_rtz(int4 v);
+OVERLOADABLE float4 convert_float4_rtp(int4 v);
+OVERLOADABLE float4 convert_float4_rtn(int4 v);
+OVERLOADABLE half4 convert_half4_rte(int4 v);
+OVERLOADABLE half4 convert_half4_rtz(int4 v);
+OVERLOADABLE half4 convert_half4_rtp(int4 v);
+OVERLOADABLE half4 convert_half4_rtn(int4 v);
+OVERLOADABLE long4 convert_long4_rte(uint4 v);
+OVERLOADABLE long4 convert_long4_rtz(uint4 v);
+OVERLOADABLE long4 convert_long4_rtp(uint4 v);
+OVERLOADABLE long4 convert_long4_rtn(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(uint4 v);
+OVERLOADABLE int4 convert_int4_rte(uint4 v);
+OVERLOADABLE int4 convert_int4_rtz(uint4 v);
+OVERLOADABLE int4 convert_int4_rtp(uint4 v);
+OVERLOADABLE int4 convert_int4_rtn(uint4 v);
+OVERLOADABLE uint4 convert_uint4_rte(uint4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(uint4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(uint4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(uint4 v);
+OVERLOADABLE short4 convert_short4_rte(uint4 v);
+OVERLOADABLE short4 convert_short4_rtz(uint4 v);
+OVERLOADABLE short4 convert_short4_rtp(uint4 v);
+OVERLOADABLE short4 convert_short4_rtn(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(uint4 v);
+OVERLOADABLE char4 convert_char4_rte(uint4 v);
+OVERLOADABLE char4 convert_char4_rtz(uint4 v);
+OVERLOADABLE char4 convert_char4_rtp(uint4 v);
+OVERLOADABLE char4 convert_char4_rtn(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(uint4 v);
+OVERLOADABLE float4 convert_float4_rte(uint4 v);
+OVERLOADABLE float4 convert_float4_rtz(uint4 v);
+OVERLOADABLE float4 convert_float4_rtp(uint4 v);
+OVERLOADABLE float4 convert_float4_rtn(uint4 v);
+OVERLOADABLE half4 convert_half4_rte(uint4 v);
+OVERLOADABLE half4 convert_half4_rtz(uint4 v);
+OVERLOADABLE half4 convert_half4_rtp(uint4 v);
+OVERLOADABLE half4 convert_half4_rtn(uint4 v);
+OVERLOADABLE long4 convert_long4_rte(short4 v);
+OVERLOADABLE long4 convert_long4_rtz(short4 v);
+OVERLOADABLE long4 convert_long4_rtp(short4 v);
+OVERLOADABLE long4 convert_long4_rtn(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(short4 v);
+OVERLOADABLE int4 convert_int4_rte(short4 v);
+OVERLOADABLE int4 convert_int4_rtz(short4 v);
+OVERLOADABLE int4 convert_int4_rtp(short4 v);
+OVERLOADABLE int4 convert_int4_rtn(short4 v);
+OVERLOADABLE uint4 convert_uint4_rte(short4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(short4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(short4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(short4 v);
+OVERLOADABLE short4 convert_short4_rte(short4 v);
+OVERLOADABLE short4 convert_short4_rtz(short4 v);
+OVERLOADABLE short4 convert_short4_rtp(short4 v);
+OVERLOADABLE short4 convert_short4_rtn(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(short4 v);
+OVERLOADABLE char4 convert_char4_rte(short4 v);
+OVERLOADABLE char4 convert_char4_rtz(short4 v);
+OVERLOADABLE char4 convert_char4_rtp(short4 v);
+OVERLOADABLE char4 convert_char4_rtn(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(short4 v);
+OVERLOADABLE float4 convert_float4_rte(short4 v);
+OVERLOADABLE float4 convert_float4_rtz(short4 v);
+OVERLOADABLE float4 convert_float4_rtp(short4 v);
+OVERLOADABLE float4 convert_float4_rtn(short4 v);
+OVERLOADABLE half4 convert_half4_rte(short4 v);
+OVERLOADABLE half4 convert_half4_rtz(short4 v);
+OVERLOADABLE half4 convert_half4_rtp(short4 v);
+OVERLOADABLE half4 convert_half4_rtn(short4 v);
+OVERLOADABLE long4 convert_long4_rte(ushort4 v);
+OVERLOADABLE long4 convert_long4_rtz(ushort4 v);
+OVERLOADABLE long4 convert_long4_rtp(ushort4 v);
+OVERLOADABLE long4 convert_long4_rtn(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(ushort4 v);
+OVERLOADABLE int4 convert_int4_rte(ushort4 v);
+OVERLOADABLE int4 convert_int4_rtz(ushort4 v);
+OVERLOADABLE int4 convert_int4_rtp(ushort4 v);
+OVERLOADABLE int4 convert_int4_rtn(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_rte(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(ushort4 v);
+OVERLOADABLE short4 convert_short4_rte(ushort4 v);
+OVERLOADABLE short4 convert_short4_rtz(ushort4 v);
+OVERLOADABLE short4 convert_short4_rtp(ushort4 v);
+OVERLOADABLE short4 convert_short4_rtn(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(ushort4 v);
+OVERLOADABLE char4 convert_char4_rte(ushort4 v);
+OVERLOADABLE char4 convert_char4_rtz(ushort4 v);
+OVERLOADABLE char4 convert_char4_rtp(ushort4 v);
+OVERLOADABLE char4 convert_char4_rtn(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(ushort4 v);
+OVERLOADABLE float4 convert_float4_rte(ushort4 v);
+OVERLOADABLE float4 convert_float4_rtz(ushort4 v);
+OVERLOADABLE float4 convert_float4_rtp(ushort4 v);
+OVERLOADABLE float4 convert_float4_rtn(ushort4 v);
+OVERLOADABLE half4 convert_half4_rte(ushort4 v);
+OVERLOADABLE half4 convert_half4_rtz(ushort4 v);
+OVERLOADABLE half4 convert_half4_rtp(ushort4 v);
+OVERLOADABLE half4 convert_half4_rtn(ushort4 v);
+OVERLOADABLE long4 convert_long4_rte(char4 v);
+OVERLOADABLE long4 convert_long4_rtz(char4 v);
+OVERLOADABLE long4 convert_long4_rtp(char4 v);
+OVERLOADABLE long4 convert_long4_rtn(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(char4 v);
+OVERLOADABLE int4 convert_int4_rte(char4 v);
+OVERLOADABLE int4 convert_int4_rtz(char4 v);
+OVERLOADABLE int4 convert_int4_rtp(char4 v);
+OVERLOADABLE int4 convert_int4_rtn(char4 v);
+OVERLOADABLE uint4 convert_uint4_rte(char4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(char4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(char4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(char4 v);
+OVERLOADABLE short4 convert_short4_rte(char4 v);
+OVERLOADABLE short4 convert_short4_rtz(char4 v);
+OVERLOADABLE short4 convert_short4_rtp(char4 v);
+OVERLOADABLE short4 convert_short4_rtn(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(char4 v);
+OVERLOADABLE char4 convert_char4_rte(char4 v);
+OVERLOADABLE char4 convert_char4_rtz(char4 v);
+OVERLOADABLE char4 convert_char4_rtp(char4 v);
+OVERLOADABLE char4 convert_char4_rtn(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(char4 v);
+OVERLOADABLE float4 convert_float4_rte(char4 v);
+OVERLOADABLE float4 convert_float4_rtz(char4 v);
+OVERLOADABLE float4 convert_float4_rtp(char4 v);
+OVERLOADABLE float4 convert_float4_rtn(char4 v);
+OVERLOADABLE half4 convert_half4_rte(char4 v);
+OVERLOADABLE half4 convert_half4_rtz(char4 v);
+OVERLOADABLE half4 convert_half4_rtp(char4 v);
+OVERLOADABLE half4 convert_half4_rtn(char4 v);
+OVERLOADABLE long4 convert_long4_rte(uchar4 v);
+OVERLOADABLE long4 convert_long4_rtz(uchar4 v);
+OVERLOADABLE long4 convert_long4_rtp(uchar4 v);
+OVERLOADABLE long4 convert_long4_rtn(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(uchar4 v);
+OVERLOADABLE int4 convert_int4_rte(uchar4 v);
+OVERLOADABLE int4 convert_int4_rtz(uchar4 v);
+OVERLOADABLE int4 convert_int4_rtp(uchar4 v);
+OVERLOADABLE int4 convert_int4_rtn(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_rte(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(uchar4 v);
+OVERLOADABLE short4 convert_short4_rte(uchar4 v);
+OVERLOADABLE short4 convert_short4_rtz(uchar4 v);
+OVERLOADABLE short4 convert_short4_rtp(uchar4 v);
+OVERLOADABLE short4 convert_short4_rtn(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(uchar4 v);
+OVERLOADABLE char4 convert_char4_rte(uchar4 v);
+OVERLOADABLE char4 convert_char4_rtz(uchar4 v);
+OVERLOADABLE char4 convert_char4_rtp(uchar4 v);
+OVERLOADABLE char4 convert_char4_rtn(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(uchar4 v);
+OVERLOADABLE float4 convert_float4_rte(uchar4 v);
+OVERLOADABLE float4 convert_float4_rtz(uchar4 v);
+OVERLOADABLE float4 convert_float4_rtp(uchar4 v);
+OVERLOADABLE float4 convert_float4_rtn(uchar4 v);
+OVERLOADABLE half4 convert_half4_rte(uchar4 v);
+OVERLOADABLE half4 convert_half4_rtz(uchar4 v);
+OVERLOADABLE half4 convert_half4_rtp(uchar4 v);
+OVERLOADABLE half4 convert_half4_rtn(uchar4 v);
+OVERLOADABLE long4 convert_long4_rte(double4 v);
+OVERLOADABLE long4 convert_long4_rtz(double4 v);
+OVERLOADABLE long4 convert_long4_rtp(double4 v);
+OVERLOADABLE long4 convert_long4_rtn(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(double4 v);
+OVERLOADABLE int4 convert_int4_rte(double4 v);
+OVERLOADABLE int4 convert_int4_rtz(double4 v);
+OVERLOADABLE int4 convert_int4_rtp(double4 v);
+OVERLOADABLE int4 convert_int4_rtn(double4 v);
+OVERLOADABLE uint4 convert_uint4_rte(double4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(double4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(double4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(double4 v);
+OVERLOADABLE short4 convert_short4_rte(double4 v);
+OVERLOADABLE short4 convert_short4_rtz(double4 v);
+OVERLOADABLE short4 convert_short4_rtp(double4 v);
+OVERLOADABLE short4 convert_short4_rtn(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(double4 v);
+OVERLOADABLE char4 convert_char4_rte(double4 v);
+OVERLOADABLE char4 convert_char4_rtz(double4 v);
+OVERLOADABLE char4 convert_char4_rtp(double4 v);
+OVERLOADABLE char4 convert_char4_rtn(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(double4 v);
+OVERLOADABLE float4 convert_float4_rte(double4 v);
+OVERLOADABLE float4 convert_float4_rtz(double4 v);
+OVERLOADABLE float4 convert_float4_rtp(double4 v);
+OVERLOADABLE float4 convert_float4_rtn(double4 v);
+OVERLOADABLE half4 convert_half4_rte(double4 v);
+OVERLOADABLE half4 convert_half4_rtz(double4 v);
+OVERLOADABLE half4 convert_half4_rtp(double4 v);
+OVERLOADABLE half4 convert_half4_rtn(double4 v);
+OVERLOADABLE long4 convert_long4_rte(float4 v);
+OVERLOADABLE long4 convert_long4_rtz(float4 v);
+OVERLOADABLE long4 convert_long4_rtp(float4 v);
+OVERLOADABLE long4 convert_long4_rtn(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(float4 v);
+OVERLOADABLE int4 convert_int4_rte(float4 v);
+OVERLOADABLE int4 convert_int4_rtz(float4 v);
+OVERLOADABLE int4 convert_int4_rtp(float4 v);
+OVERLOADABLE int4 convert_int4_rtn(float4 v);
+OVERLOADABLE uint4 convert_uint4_rte(float4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(float4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(float4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(float4 v);
+OVERLOADABLE short4 convert_short4_rte(float4 v);
+OVERLOADABLE short4 convert_short4_rtz(float4 v);
+OVERLOADABLE short4 convert_short4_rtp(float4 v);
+OVERLOADABLE short4 convert_short4_rtn(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(float4 v);
+OVERLOADABLE char4 convert_char4_rte(float4 v);
+OVERLOADABLE char4 convert_char4_rtz(float4 v);
+OVERLOADABLE char4 convert_char4_rtp(float4 v);
+OVERLOADABLE char4 convert_char4_rtn(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(float4 v);
+OVERLOADABLE float4 convert_float4_rte(float4 v);
+OVERLOADABLE float4 convert_float4_rtz(float4 v);
+OVERLOADABLE float4 convert_float4_rtp(float4 v);
+OVERLOADABLE float4 convert_float4_rtn(float4 v);
+OVERLOADABLE half4 convert_half4_rte(float4 v);
+OVERLOADABLE half4 convert_half4_rtz(float4 v);
+OVERLOADABLE half4 convert_half4_rtp(float4 v);
+OVERLOADABLE half4 convert_half4_rtn(float4 v);
+OVERLOADABLE long4 convert_long4_rte(half4 v);
+OVERLOADABLE long4 convert_long4_rtz(half4 v);
+OVERLOADABLE long4 convert_long4_rtp(half4 v);
+OVERLOADABLE long4 convert_long4_rtn(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_rte(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtz(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtp(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_rtn(half4 v);
+OVERLOADABLE int4 convert_int4_rte(half4 v);
+OVERLOADABLE int4 convert_int4_rtz(half4 v);
+OVERLOADABLE int4 convert_int4_rtp(half4 v);
+OVERLOADABLE int4 convert_int4_rtn(half4 v);
+OVERLOADABLE uint4 convert_uint4_rte(half4 v);
+OVERLOADABLE uint4 convert_uint4_rtz(half4 v);
+OVERLOADABLE uint4 convert_uint4_rtp(half4 v);
+OVERLOADABLE uint4 convert_uint4_rtn(half4 v);
+OVERLOADABLE short4 convert_short4_rte(half4 v);
+OVERLOADABLE short4 convert_short4_rtz(half4 v);
+OVERLOADABLE short4 convert_short4_rtp(half4 v);
+OVERLOADABLE short4 convert_short4_rtn(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_rte(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtz(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtp(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_rtn(half4 v);
+OVERLOADABLE char4 convert_char4_rte(half4 v);
+OVERLOADABLE char4 convert_char4_rtz(half4 v);
+OVERLOADABLE char4 convert_char4_rtp(half4 v);
+OVERLOADABLE char4 convert_char4_rtn(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_rte(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtz(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtp(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_rtn(half4 v);
+OVERLOADABLE float4 convert_float4_rte(half4 v);
+OVERLOADABLE float4 convert_float4_rtz(half4 v);
+OVERLOADABLE float4 convert_float4_rtp(half4 v);
+OVERLOADABLE float4 convert_float4_rtn(half4 v);
+OVERLOADABLE half4 convert_half4_rte(half4 v);
+OVERLOADABLE half4 convert_half4_rtz(half4 v);
+OVERLOADABLE half4 convert_half4_rtp(half4 v);
+OVERLOADABLE half4 convert_half4_rtn(half4 v);
+OVERLOADABLE long8 convert_long8_rte(long8 v);
+OVERLOADABLE long8 convert_long8_rtz(long8 v);
+OVERLOADABLE long8 convert_long8_rtp(long8 v);
+OVERLOADABLE long8 convert_long8_rtn(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(long8 v);
+OVERLOADABLE int8 convert_int8_rte(long8 v);
+OVERLOADABLE int8 convert_int8_rtz(long8 v);
+OVERLOADABLE int8 convert_int8_rtp(long8 v);
+OVERLOADABLE int8 convert_int8_rtn(long8 v);
+OVERLOADABLE uint8 convert_uint8_rte(long8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(long8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(long8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(long8 v);
+OVERLOADABLE short8 convert_short8_rte(long8 v);
+OVERLOADABLE short8 convert_short8_rtz(long8 v);
+OVERLOADABLE short8 convert_short8_rtp(long8 v);
+OVERLOADABLE short8 convert_short8_rtn(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(long8 v);
+OVERLOADABLE char8 convert_char8_rte(long8 v);
+OVERLOADABLE char8 convert_char8_rtz(long8 v);
+OVERLOADABLE char8 convert_char8_rtp(long8 v);
+OVERLOADABLE char8 convert_char8_rtn(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(long8 v);
+OVERLOADABLE float8 convert_float8_rte(long8 v);
+OVERLOADABLE float8 convert_float8_rtz(long8 v);
+OVERLOADABLE float8 convert_float8_rtp(long8 v);
+OVERLOADABLE float8 convert_float8_rtn(long8 v);
+OVERLOADABLE half8 convert_half8_rte(long8 v);
+OVERLOADABLE half8 convert_half8_rtz(long8 v);
+OVERLOADABLE half8 convert_half8_rtp(long8 v);
+OVERLOADABLE half8 convert_half8_rtn(long8 v);
+OVERLOADABLE long8 convert_long8_rte(ulong8 v);
+OVERLOADABLE long8 convert_long8_rtz(ulong8 v);
+OVERLOADABLE long8 convert_long8_rtp(ulong8 v);
+OVERLOADABLE long8 convert_long8_rtn(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(ulong8 v);
+OVERLOADABLE int8 convert_int8_rte(ulong8 v);
+OVERLOADABLE int8 convert_int8_rtz(ulong8 v);
+OVERLOADABLE int8 convert_int8_rtp(ulong8 v);
+OVERLOADABLE int8 convert_int8_rtn(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_rte(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(ulong8 v);
+OVERLOADABLE short8 convert_short8_rte(ulong8 v);
+OVERLOADABLE short8 convert_short8_rtz(ulong8 v);
+OVERLOADABLE short8 convert_short8_rtp(ulong8 v);
+OVERLOADABLE short8 convert_short8_rtn(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(ulong8 v);
+OVERLOADABLE char8 convert_char8_rte(ulong8 v);
+OVERLOADABLE char8 convert_char8_rtz(ulong8 v);
+OVERLOADABLE char8 convert_char8_rtp(ulong8 v);
+OVERLOADABLE char8 convert_char8_rtn(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(ulong8 v);
+OVERLOADABLE float8 convert_float8_rte(ulong8 v);
+OVERLOADABLE float8 convert_float8_rtz(ulong8 v);
+OVERLOADABLE float8 convert_float8_rtp(ulong8 v);
+OVERLOADABLE float8 convert_float8_rtn(ulong8 v);
+OVERLOADABLE half8 convert_half8_rte(ulong8 v);
+OVERLOADABLE half8 convert_half8_rtz(ulong8 v);
+OVERLOADABLE half8 convert_half8_rtp(ulong8 v);
+OVERLOADABLE half8 convert_half8_rtn(ulong8 v);
+OVERLOADABLE long8 convert_long8_rte(int8 v);
+OVERLOADABLE long8 convert_long8_rtz(int8 v);
+OVERLOADABLE long8 convert_long8_rtp(int8 v);
+OVERLOADABLE long8 convert_long8_rtn(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(int8 v);
+OVERLOADABLE int8 convert_int8_rte(int8 v);
+OVERLOADABLE int8 convert_int8_rtz(int8 v);
+OVERLOADABLE int8 convert_int8_rtp(int8 v);
+OVERLOADABLE int8 convert_int8_rtn(int8 v);
+OVERLOADABLE uint8 convert_uint8_rte(int8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(int8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(int8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(int8 v);
+OVERLOADABLE short8 convert_short8_rte(int8 v);
+OVERLOADABLE short8 convert_short8_rtz(int8 v);
+OVERLOADABLE short8 convert_short8_rtp(int8 v);
+OVERLOADABLE short8 convert_short8_rtn(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(int8 v);
+OVERLOADABLE char8 convert_char8_rte(int8 v);
+OVERLOADABLE char8 convert_char8_rtz(int8 v);
+OVERLOADABLE char8 convert_char8_rtp(int8 v);
+OVERLOADABLE char8 convert_char8_rtn(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(int8 v);
+OVERLOADABLE float8 convert_float8_rte(int8 v);
+OVERLOADABLE float8 convert_float8_rtz(int8 v);
+OVERLOADABLE float8 convert_float8_rtp(int8 v);
+OVERLOADABLE float8 convert_float8_rtn(int8 v);
+OVERLOADABLE half8 convert_half8_rte(int8 v);
+OVERLOADABLE half8 convert_half8_rtz(int8 v);
+OVERLOADABLE half8 convert_half8_rtp(int8 v);
+OVERLOADABLE half8 convert_half8_rtn(int8 v);
+OVERLOADABLE long8 convert_long8_rte(uint8 v);
+OVERLOADABLE long8 convert_long8_rtz(uint8 v);
+OVERLOADABLE long8 convert_long8_rtp(uint8 v);
+OVERLOADABLE long8 convert_long8_rtn(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(uint8 v);
+OVERLOADABLE int8 convert_int8_rte(uint8 v);
+OVERLOADABLE int8 convert_int8_rtz(uint8 v);
+OVERLOADABLE int8 convert_int8_rtp(uint8 v);
+OVERLOADABLE int8 convert_int8_rtn(uint8 v);
+OVERLOADABLE uint8 convert_uint8_rte(uint8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(uint8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(uint8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(uint8 v);
+OVERLOADABLE short8 convert_short8_rte(uint8 v);
+OVERLOADABLE short8 convert_short8_rtz(uint8 v);
+OVERLOADABLE short8 convert_short8_rtp(uint8 v);
+OVERLOADABLE short8 convert_short8_rtn(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(uint8 v);
+OVERLOADABLE char8 convert_char8_rte(uint8 v);
+OVERLOADABLE char8 convert_char8_rtz(uint8 v);
+OVERLOADABLE char8 convert_char8_rtp(uint8 v);
+OVERLOADABLE char8 convert_char8_rtn(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(uint8 v);
+OVERLOADABLE float8 convert_float8_rte(uint8 v);
+OVERLOADABLE float8 convert_float8_rtz(uint8 v);
+OVERLOADABLE float8 convert_float8_rtp(uint8 v);
+OVERLOADABLE float8 convert_float8_rtn(uint8 v);
+OVERLOADABLE half8 convert_half8_rte(uint8 v);
+OVERLOADABLE half8 convert_half8_rtz(uint8 v);
+OVERLOADABLE half8 convert_half8_rtp(uint8 v);
+OVERLOADABLE half8 convert_half8_rtn(uint8 v);
+OVERLOADABLE long8 convert_long8_rte(short8 v);
+OVERLOADABLE long8 convert_long8_rtz(short8 v);
+OVERLOADABLE long8 convert_long8_rtp(short8 v);
+OVERLOADABLE long8 convert_long8_rtn(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(short8 v);
+OVERLOADABLE int8 convert_int8_rte(short8 v);
+OVERLOADABLE int8 convert_int8_rtz(short8 v);
+OVERLOADABLE int8 convert_int8_rtp(short8 v);
+OVERLOADABLE int8 convert_int8_rtn(short8 v);
+OVERLOADABLE uint8 convert_uint8_rte(short8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(short8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(short8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(short8 v);
+OVERLOADABLE short8 convert_short8_rte(short8 v);
+OVERLOADABLE short8 convert_short8_rtz(short8 v);
+OVERLOADABLE short8 convert_short8_rtp(short8 v);
+OVERLOADABLE short8 convert_short8_rtn(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(short8 v);
+OVERLOADABLE char8 convert_char8_rte(short8 v);
+OVERLOADABLE char8 convert_char8_rtz(short8 v);
+OVERLOADABLE char8 convert_char8_rtp(short8 v);
+OVERLOADABLE char8 convert_char8_rtn(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(short8 v);
+OVERLOADABLE float8 convert_float8_rte(short8 v);
+OVERLOADABLE float8 convert_float8_rtz(short8 v);
+OVERLOADABLE float8 convert_float8_rtp(short8 v);
+OVERLOADABLE float8 convert_float8_rtn(short8 v);
+OVERLOADABLE half8 convert_half8_rte(short8 v);
+OVERLOADABLE half8 convert_half8_rtz(short8 v);
+OVERLOADABLE half8 convert_half8_rtp(short8 v);
+OVERLOADABLE half8 convert_half8_rtn(short8 v);
+OVERLOADABLE long8 convert_long8_rte(ushort8 v);
+OVERLOADABLE long8 convert_long8_rtz(ushort8 v);
+OVERLOADABLE long8 convert_long8_rtp(ushort8 v);
+OVERLOADABLE long8 convert_long8_rtn(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(ushort8 v);
+OVERLOADABLE int8 convert_int8_rte(ushort8 v);
+OVERLOADABLE int8 convert_int8_rtz(ushort8 v);
+OVERLOADABLE int8 convert_int8_rtp(ushort8 v);
+OVERLOADABLE int8 convert_int8_rtn(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_rte(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(ushort8 v);
+OVERLOADABLE short8 convert_short8_rte(ushort8 v);
+OVERLOADABLE short8 convert_short8_rtz(ushort8 v);
+OVERLOADABLE short8 convert_short8_rtp(ushort8 v);
+OVERLOADABLE short8 convert_short8_rtn(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(ushort8 v);
+OVERLOADABLE char8 convert_char8_rte(ushort8 v);
+OVERLOADABLE char8 convert_char8_rtz(ushort8 v);
+OVERLOADABLE char8 convert_char8_rtp(ushort8 v);
+OVERLOADABLE char8 convert_char8_rtn(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(ushort8 v);
+OVERLOADABLE float8 convert_float8_rte(ushort8 v);
+OVERLOADABLE float8 convert_float8_rtz(ushort8 v);
+OVERLOADABLE float8 convert_float8_rtp(ushort8 v);
+OVERLOADABLE float8 convert_float8_rtn(ushort8 v);
+OVERLOADABLE half8 convert_half8_rte(ushort8 v);
+OVERLOADABLE half8 convert_half8_rtz(ushort8 v);
+OVERLOADABLE half8 convert_half8_rtp(ushort8 v);
+OVERLOADABLE half8 convert_half8_rtn(ushort8 v);
+OVERLOADABLE long8 convert_long8_rte(char8 v);
+OVERLOADABLE long8 convert_long8_rtz(char8 v);
+OVERLOADABLE long8 convert_long8_rtp(char8 v);
+OVERLOADABLE long8 convert_long8_rtn(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(char8 v);
+OVERLOADABLE int8 convert_int8_rte(char8 v);
+OVERLOADABLE int8 convert_int8_rtz(char8 v);
+OVERLOADABLE int8 convert_int8_rtp(char8 v);
+OVERLOADABLE int8 convert_int8_rtn(char8 v);
+OVERLOADABLE uint8 convert_uint8_rte(char8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(char8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(char8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(char8 v);
+OVERLOADABLE short8 convert_short8_rte(char8 v);
+OVERLOADABLE short8 convert_short8_rtz(char8 v);
+OVERLOADABLE short8 convert_short8_rtp(char8 v);
+OVERLOADABLE short8 convert_short8_rtn(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(char8 v);
+OVERLOADABLE char8 convert_char8_rte(char8 v);
+OVERLOADABLE char8 convert_char8_rtz(char8 v);
+OVERLOADABLE char8 convert_char8_rtp(char8 v);
+OVERLOADABLE char8 convert_char8_rtn(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(char8 v);
+OVERLOADABLE float8 convert_float8_rte(char8 v);
+OVERLOADABLE float8 convert_float8_rtz(char8 v);
+OVERLOADABLE float8 convert_float8_rtp(char8 v);
+OVERLOADABLE float8 convert_float8_rtn(char8 v);
+OVERLOADABLE half8 convert_half8_rte(char8 v);
+OVERLOADABLE half8 convert_half8_rtz(char8 v);
+OVERLOADABLE half8 convert_half8_rtp(char8 v);
+OVERLOADABLE half8 convert_half8_rtn(char8 v);
+OVERLOADABLE long8 convert_long8_rte(uchar8 v);
+OVERLOADABLE long8 convert_long8_rtz(uchar8 v);
+OVERLOADABLE long8 convert_long8_rtp(uchar8 v);
+OVERLOADABLE long8 convert_long8_rtn(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(uchar8 v);
+OVERLOADABLE int8 convert_int8_rte(uchar8 v);
+OVERLOADABLE int8 convert_int8_rtz(uchar8 v);
+OVERLOADABLE int8 convert_int8_rtp(uchar8 v);
+OVERLOADABLE int8 convert_int8_rtn(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_rte(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(uchar8 v);
+OVERLOADABLE short8 convert_short8_rte(uchar8 v);
+OVERLOADABLE short8 convert_short8_rtz(uchar8 v);
+OVERLOADABLE short8 convert_short8_rtp(uchar8 v);
+OVERLOADABLE short8 convert_short8_rtn(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(uchar8 v);
+OVERLOADABLE char8 convert_char8_rte(uchar8 v);
+OVERLOADABLE char8 convert_char8_rtz(uchar8 v);
+OVERLOADABLE char8 convert_char8_rtp(uchar8 v);
+OVERLOADABLE char8 convert_char8_rtn(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(uchar8 v);
+OVERLOADABLE float8 convert_float8_rte(uchar8 v);
+OVERLOADABLE float8 convert_float8_rtz(uchar8 v);
+OVERLOADABLE float8 convert_float8_rtp(uchar8 v);
+OVERLOADABLE float8 convert_float8_rtn(uchar8 v);
+OVERLOADABLE half8 convert_half8_rte(uchar8 v);
+OVERLOADABLE half8 convert_half8_rtz(uchar8 v);
+OVERLOADABLE half8 convert_half8_rtp(uchar8 v);
+OVERLOADABLE half8 convert_half8_rtn(uchar8 v);
+OVERLOADABLE long8 convert_long8_rte(double8 v);
+OVERLOADABLE long8 convert_long8_rtz(double8 v);
+OVERLOADABLE long8 convert_long8_rtp(double8 v);
+OVERLOADABLE long8 convert_long8_rtn(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(double8 v);
+OVERLOADABLE int8 convert_int8_rte(double8 v);
+OVERLOADABLE int8 convert_int8_rtz(double8 v);
+OVERLOADABLE int8 convert_int8_rtp(double8 v);
+OVERLOADABLE int8 convert_int8_rtn(double8 v);
+OVERLOADABLE uint8 convert_uint8_rte(double8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(double8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(double8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(double8 v);
+OVERLOADABLE short8 convert_short8_rte(double8 v);
+OVERLOADABLE short8 convert_short8_rtz(double8 v);
+OVERLOADABLE short8 convert_short8_rtp(double8 v);
+OVERLOADABLE short8 convert_short8_rtn(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(double8 v);
+OVERLOADABLE char8 convert_char8_rte(double8 v);
+OVERLOADABLE char8 convert_char8_rtz(double8 v);
+OVERLOADABLE char8 convert_char8_rtp(double8 v);
+OVERLOADABLE char8 convert_char8_rtn(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(double8 v);
+OVERLOADABLE float8 convert_float8_rte(double8 v);
+OVERLOADABLE float8 convert_float8_rtz(double8 v);
+OVERLOADABLE float8 convert_float8_rtp(double8 v);
+OVERLOADABLE float8 convert_float8_rtn(double8 v);
+OVERLOADABLE half8 convert_half8_rte(double8 v);
+OVERLOADABLE half8 convert_half8_rtz(double8 v);
+OVERLOADABLE half8 convert_half8_rtp(double8 v);
+OVERLOADABLE half8 convert_half8_rtn(double8 v);
+OVERLOADABLE long8 convert_long8_rte(float8 v);
+OVERLOADABLE long8 convert_long8_rtz(float8 v);
+OVERLOADABLE long8 convert_long8_rtp(float8 v);
+OVERLOADABLE long8 convert_long8_rtn(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(float8 v);
+OVERLOADABLE int8 convert_int8_rte(float8 v);
+OVERLOADABLE int8 convert_int8_rtz(float8 v);
+OVERLOADABLE int8 convert_int8_rtp(float8 v);
+OVERLOADABLE int8 convert_int8_rtn(float8 v);
+OVERLOADABLE uint8 convert_uint8_rte(float8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(float8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(float8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(float8 v);
+OVERLOADABLE short8 convert_short8_rte(float8 v);
+OVERLOADABLE short8 convert_short8_rtz(float8 v);
+OVERLOADABLE short8 convert_short8_rtp(float8 v);
+OVERLOADABLE short8 convert_short8_rtn(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(float8 v);
+OVERLOADABLE char8 convert_char8_rte(float8 v);
+OVERLOADABLE char8 convert_char8_rtz(float8 v);
+OVERLOADABLE char8 convert_char8_rtp(float8 v);
+OVERLOADABLE char8 convert_char8_rtn(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(float8 v);
+OVERLOADABLE float8 convert_float8_rte(float8 v);
+OVERLOADABLE float8 convert_float8_rtz(float8 v);
+OVERLOADABLE float8 convert_float8_rtp(float8 v);
+OVERLOADABLE float8 convert_float8_rtn(float8 v);
+OVERLOADABLE half8 convert_half8_rte(float8 v);
+OVERLOADABLE half8 convert_half8_rtz(float8 v);
+OVERLOADABLE half8 convert_half8_rtp(float8 v);
+OVERLOADABLE half8 convert_half8_rtn(float8 v);
+OVERLOADABLE long8 convert_long8_rte(half8 v);
+OVERLOADABLE long8 convert_long8_rtz(half8 v);
+OVERLOADABLE long8 convert_long8_rtp(half8 v);
+OVERLOADABLE long8 convert_long8_rtn(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_rte(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtz(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtp(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_rtn(half8 v);
+OVERLOADABLE int8 convert_int8_rte(half8 v);
+OVERLOADABLE int8 convert_int8_rtz(half8 v);
+OVERLOADABLE int8 convert_int8_rtp(half8 v);
+OVERLOADABLE int8 convert_int8_rtn(half8 v);
+OVERLOADABLE uint8 convert_uint8_rte(half8 v);
+OVERLOADABLE uint8 convert_uint8_rtz(half8 v);
+OVERLOADABLE uint8 convert_uint8_rtp(half8 v);
+OVERLOADABLE uint8 convert_uint8_rtn(half8 v);
+OVERLOADABLE short8 convert_short8_rte(half8 v);
+OVERLOADABLE short8 convert_short8_rtz(half8 v);
+OVERLOADABLE short8 convert_short8_rtp(half8 v);
+OVERLOADABLE short8 convert_short8_rtn(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_rte(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtz(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtp(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_rtn(half8 v);
+OVERLOADABLE char8 convert_char8_rte(half8 v);
+OVERLOADABLE char8 convert_char8_rtz(half8 v);
+OVERLOADABLE char8 convert_char8_rtp(half8 v);
+OVERLOADABLE char8 convert_char8_rtn(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_rte(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtz(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtp(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_rtn(half8 v);
+OVERLOADABLE float8 convert_float8_rte(half8 v);
+OVERLOADABLE float8 convert_float8_rtz(half8 v);
+OVERLOADABLE float8 convert_float8_rtp(half8 v);
+OVERLOADABLE float8 convert_float8_rtn(half8 v);
+OVERLOADABLE half8 convert_half8_rte(half8 v);
+OVERLOADABLE half8 convert_half8_rtz(half8 v);
+OVERLOADABLE half8 convert_half8_rtp(half8 v);
+OVERLOADABLE half8 convert_half8_rtn(half8 v);
+OVERLOADABLE long16 convert_long16_rte(long16 v);
+OVERLOADABLE long16 convert_long16_rtz(long16 v);
+OVERLOADABLE long16 convert_long16_rtp(long16 v);
+OVERLOADABLE long16 convert_long16_rtn(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(long16 v);
+OVERLOADABLE int16 convert_int16_rte(long16 v);
+OVERLOADABLE int16 convert_int16_rtz(long16 v);
+OVERLOADABLE int16 convert_int16_rtp(long16 v);
+OVERLOADABLE int16 convert_int16_rtn(long16 v);
+OVERLOADABLE uint16 convert_uint16_rte(long16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(long16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(long16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(long16 v);
+OVERLOADABLE short16 convert_short16_rte(long16 v);
+OVERLOADABLE short16 convert_short16_rtz(long16 v);
+OVERLOADABLE short16 convert_short16_rtp(long16 v);
+OVERLOADABLE short16 convert_short16_rtn(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(long16 v);
+OVERLOADABLE char16 convert_char16_rte(long16 v);
+OVERLOADABLE char16 convert_char16_rtz(long16 v);
+OVERLOADABLE char16 convert_char16_rtp(long16 v);
+OVERLOADABLE char16 convert_char16_rtn(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(long16 v);
+OVERLOADABLE float16 convert_float16_rte(long16 v);
+OVERLOADABLE float16 convert_float16_rtz(long16 v);
+OVERLOADABLE float16 convert_float16_rtp(long16 v);
+OVERLOADABLE float16 convert_float16_rtn(long16 v);
+OVERLOADABLE half16 convert_half16_rte(long16 v);
+OVERLOADABLE half16 convert_half16_rtz(long16 v);
+OVERLOADABLE half16 convert_half16_rtp(long16 v);
+OVERLOADABLE half16 convert_half16_rtn(long16 v);
+OVERLOADABLE long16 convert_long16_rte(ulong16 v);
+OVERLOADABLE long16 convert_long16_rtz(ulong16 v);
+OVERLOADABLE long16 convert_long16_rtp(ulong16 v);
+OVERLOADABLE long16 convert_long16_rtn(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(ulong16 v);
+OVERLOADABLE int16 convert_int16_rte(ulong16 v);
+OVERLOADABLE int16 convert_int16_rtz(ulong16 v);
+OVERLOADABLE int16 convert_int16_rtp(ulong16 v);
+OVERLOADABLE int16 convert_int16_rtn(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_rte(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(ulong16 v);
+OVERLOADABLE short16 convert_short16_rte(ulong16 v);
+OVERLOADABLE short16 convert_short16_rtz(ulong16 v);
+OVERLOADABLE short16 convert_short16_rtp(ulong16 v);
+OVERLOADABLE short16 convert_short16_rtn(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(ulong16 v);
+OVERLOADABLE char16 convert_char16_rte(ulong16 v);
+OVERLOADABLE char16 convert_char16_rtz(ulong16 v);
+OVERLOADABLE char16 convert_char16_rtp(ulong16 v);
+OVERLOADABLE char16 convert_char16_rtn(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(ulong16 v);
+OVERLOADABLE float16 convert_float16_rte(ulong16 v);
+OVERLOADABLE float16 convert_float16_rtz(ulong16 v);
+OVERLOADABLE float16 convert_float16_rtp(ulong16 v);
+OVERLOADABLE float16 convert_float16_rtn(ulong16 v);
+OVERLOADABLE half16 convert_half16_rte(ulong16 v);
+OVERLOADABLE half16 convert_half16_rtz(ulong16 v);
+OVERLOADABLE half16 convert_half16_rtp(ulong16 v);
+OVERLOADABLE half16 convert_half16_rtn(ulong16 v);
+OVERLOADABLE long16 convert_long16_rte(int16 v);
+OVERLOADABLE long16 convert_long16_rtz(int16 v);
+OVERLOADABLE long16 convert_long16_rtp(int16 v);
+OVERLOADABLE long16 convert_long16_rtn(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(int16 v);
+OVERLOADABLE int16 convert_int16_rte(int16 v);
+OVERLOADABLE int16 convert_int16_rtz(int16 v);
+OVERLOADABLE int16 convert_int16_rtp(int16 v);
+OVERLOADABLE int16 convert_int16_rtn(int16 v);
+OVERLOADABLE uint16 convert_uint16_rte(int16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(int16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(int16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(int16 v);
+OVERLOADABLE short16 convert_short16_rte(int16 v);
+OVERLOADABLE short16 convert_short16_rtz(int16 v);
+OVERLOADABLE short16 convert_short16_rtp(int16 v);
+OVERLOADABLE short16 convert_short16_rtn(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(int16 v);
+OVERLOADABLE char16 convert_char16_rte(int16 v);
+OVERLOADABLE char16 convert_char16_rtz(int16 v);
+OVERLOADABLE char16 convert_char16_rtp(int16 v);
+OVERLOADABLE char16 convert_char16_rtn(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(int16 v);
+OVERLOADABLE float16 convert_float16_rte(int16 v);
+OVERLOADABLE float16 convert_float16_rtz(int16 v);
+OVERLOADABLE float16 convert_float16_rtp(int16 v);
+OVERLOADABLE float16 convert_float16_rtn(int16 v);
+OVERLOADABLE half16 convert_half16_rte(int16 v);
+OVERLOADABLE half16 convert_half16_rtz(int16 v);
+OVERLOADABLE half16 convert_half16_rtp(int16 v);
+OVERLOADABLE half16 convert_half16_rtn(int16 v);
+OVERLOADABLE long16 convert_long16_rte(uint16 v);
+OVERLOADABLE long16 convert_long16_rtz(uint16 v);
+OVERLOADABLE long16 convert_long16_rtp(uint16 v);
+OVERLOADABLE long16 convert_long16_rtn(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(uint16 v);
+OVERLOADABLE int16 convert_int16_rte(uint16 v);
+OVERLOADABLE int16 convert_int16_rtz(uint16 v);
+OVERLOADABLE int16 convert_int16_rtp(uint16 v);
+OVERLOADABLE int16 convert_int16_rtn(uint16 v);
+OVERLOADABLE uint16 convert_uint16_rte(uint16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(uint16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(uint16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(uint16 v);
+OVERLOADABLE short16 convert_short16_rte(uint16 v);
+OVERLOADABLE short16 convert_short16_rtz(uint16 v);
+OVERLOADABLE short16 convert_short16_rtp(uint16 v);
+OVERLOADABLE short16 convert_short16_rtn(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(uint16 v);
+OVERLOADABLE char16 convert_char16_rte(uint16 v);
+OVERLOADABLE char16 convert_char16_rtz(uint16 v);
+OVERLOADABLE char16 convert_char16_rtp(uint16 v);
+OVERLOADABLE char16 convert_char16_rtn(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(uint16 v);
+OVERLOADABLE float16 convert_float16_rte(uint16 v);
+OVERLOADABLE float16 convert_float16_rtz(uint16 v);
+OVERLOADABLE float16 convert_float16_rtp(uint16 v);
+OVERLOADABLE float16 convert_float16_rtn(uint16 v);
+OVERLOADABLE half16 convert_half16_rte(uint16 v);
+OVERLOADABLE half16 convert_half16_rtz(uint16 v);
+OVERLOADABLE half16 convert_half16_rtp(uint16 v);
+OVERLOADABLE half16 convert_half16_rtn(uint16 v);
+OVERLOADABLE long16 convert_long16_rte(short16 v);
+OVERLOADABLE long16 convert_long16_rtz(short16 v);
+OVERLOADABLE long16 convert_long16_rtp(short16 v);
+OVERLOADABLE long16 convert_long16_rtn(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(short16 v);
+OVERLOADABLE int16 convert_int16_rte(short16 v);
+OVERLOADABLE int16 convert_int16_rtz(short16 v);
+OVERLOADABLE int16 convert_int16_rtp(short16 v);
+OVERLOADABLE int16 convert_int16_rtn(short16 v);
+OVERLOADABLE uint16 convert_uint16_rte(short16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(short16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(short16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(short16 v);
+OVERLOADABLE short16 convert_short16_rte(short16 v);
+OVERLOADABLE short16 convert_short16_rtz(short16 v);
+OVERLOADABLE short16 convert_short16_rtp(short16 v);
+OVERLOADABLE short16 convert_short16_rtn(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(short16 v);
+OVERLOADABLE char16 convert_char16_rte(short16 v);
+OVERLOADABLE char16 convert_char16_rtz(short16 v);
+OVERLOADABLE char16 convert_char16_rtp(short16 v);
+OVERLOADABLE char16 convert_char16_rtn(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(short16 v);
+OVERLOADABLE float16 convert_float16_rte(short16 v);
+OVERLOADABLE float16 convert_float16_rtz(short16 v);
+OVERLOADABLE float16 convert_float16_rtp(short16 v);
+OVERLOADABLE float16 convert_float16_rtn(short16 v);
+OVERLOADABLE half16 convert_half16_rte(short16 v);
+OVERLOADABLE half16 convert_half16_rtz(short16 v);
+OVERLOADABLE half16 convert_half16_rtp(short16 v);
+OVERLOADABLE half16 convert_half16_rtn(short16 v);
+OVERLOADABLE long16 convert_long16_rte(ushort16 v);
+OVERLOADABLE long16 convert_long16_rtz(ushort16 v);
+OVERLOADABLE long16 convert_long16_rtp(ushort16 v);
+OVERLOADABLE long16 convert_long16_rtn(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(ushort16 v);
+OVERLOADABLE int16 convert_int16_rte(ushort16 v);
+OVERLOADABLE int16 convert_int16_rtz(ushort16 v);
+OVERLOADABLE int16 convert_int16_rtp(ushort16 v);
+OVERLOADABLE int16 convert_int16_rtn(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_rte(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(ushort16 v);
+OVERLOADABLE short16 convert_short16_rte(ushort16 v);
+OVERLOADABLE short16 convert_short16_rtz(ushort16 v);
+OVERLOADABLE short16 convert_short16_rtp(ushort16 v);
+OVERLOADABLE short16 convert_short16_rtn(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(ushort16 v);
+OVERLOADABLE char16 convert_char16_rte(ushort16 v);
+OVERLOADABLE char16 convert_char16_rtz(ushort16 v);
+OVERLOADABLE char16 convert_char16_rtp(ushort16 v);
+OVERLOADABLE char16 convert_char16_rtn(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(ushort16 v);
+OVERLOADABLE float16 convert_float16_rte(ushort16 v);
+OVERLOADABLE float16 convert_float16_rtz(ushort16 v);
+OVERLOADABLE float16 convert_float16_rtp(ushort16 v);
+OVERLOADABLE float16 convert_float16_rtn(ushort16 v);
+OVERLOADABLE half16 convert_half16_rte(ushort16 v);
+OVERLOADABLE half16 convert_half16_rtz(ushort16 v);
+OVERLOADABLE half16 convert_half16_rtp(ushort16 v);
+OVERLOADABLE half16 convert_half16_rtn(ushort16 v);
+OVERLOADABLE long16 convert_long16_rte(char16 v);
+OVERLOADABLE long16 convert_long16_rtz(char16 v);
+OVERLOADABLE long16 convert_long16_rtp(char16 v);
+OVERLOADABLE long16 convert_long16_rtn(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(char16 v);
+OVERLOADABLE int16 convert_int16_rte(char16 v);
+OVERLOADABLE int16 convert_int16_rtz(char16 v);
+OVERLOADABLE int16 convert_int16_rtp(char16 v);
+OVERLOADABLE int16 convert_int16_rtn(char16 v);
+OVERLOADABLE uint16 convert_uint16_rte(char16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(char16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(char16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(char16 v);
+OVERLOADABLE short16 convert_short16_rte(char16 v);
+OVERLOADABLE short16 convert_short16_rtz(char16 v);
+OVERLOADABLE short16 convert_short16_rtp(char16 v);
+OVERLOADABLE short16 convert_short16_rtn(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(char16 v);
+OVERLOADABLE char16 convert_char16_rte(char16 v);
+OVERLOADABLE char16 convert_char16_rtz(char16 v);
+OVERLOADABLE char16 convert_char16_rtp(char16 v);
+OVERLOADABLE char16 convert_char16_rtn(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(char16 v);
+OVERLOADABLE float16 convert_float16_rte(char16 v);
+OVERLOADABLE float16 convert_float16_rtz(char16 v);
+OVERLOADABLE float16 convert_float16_rtp(char16 v);
+OVERLOADABLE float16 convert_float16_rtn(char16 v);
+OVERLOADABLE half16 convert_half16_rte(char16 v);
+OVERLOADABLE half16 convert_half16_rtz(char16 v);
+OVERLOADABLE half16 convert_half16_rtp(char16 v);
+OVERLOADABLE half16 convert_half16_rtn(char16 v);
+OVERLOADABLE long16 convert_long16_rte(uchar16 v);
+OVERLOADABLE long16 convert_long16_rtz(uchar16 v);
+OVERLOADABLE long16 convert_long16_rtp(uchar16 v);
+OVERLOADABLE long16 convert_long16_rtn(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(uchar16 v);
+OVERLOADABLE int16 convert_int16_rte(uchar16 v);
+OVERLOADABLE int16 convert_int16_rtz(uchar16 v);
+OVERLOADABLE int16 convert_int16_rtp(uchar16 v);
+OVERLOADABLE int16 convert_int16_rtn(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_rte(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(uchar16 v);
+OVERLOADABLE short16 convert_short16_rte(uchar16 v);
+OVERLOADABLE short16 convert_short16_rtz(uchar16 v);
+OVERLOADABLE short16 convert_short16_rtp(uchar16 v);
+OVERLOADABLE short16 convert_short16_rtn(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(uchar16 v);
+OVERLOADABLE char16 convert_char16_rte(uchar16 v);
+OVERLOADABLE char16 convert_char16_rtz(uchar16 v);
+OVERLOADABLE char16 convert_char16_rtp(uchar16 v);
+OVERLOADABLE char16 convert_char16_rtn(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(uchar16 v);
+OVERLOADABLE float16 convert_float16_rte(uchar16 v);
+OVERLOADABLE float16 convert_float16_rtz(uchar16 v);
+OVERLOADABLE float16 convert_float16_rtp(uchar16 v);
+OVERLOADABLE float16 convert_float16_rtn(uchar16 v);
+OVERLOADABLE half16 convert_half16_rte(uchar16 v);
+OVERLOADABLE half16 convert_half16_rtz(uchar16 v);
+OVERLOADABLE half16 convert_half16_rtp(uchar16 v);
+OVERLOADABLE half16 convert_half16_rtn(uchar16 v);
+OVERLOADABLE long16 convert_long16_rte(double16 v);
+OVERLOADABLE long16 convert_long16_rtz(double16 v);
+OVERLOADABLE long16 convert_long16_rtp(double16 v);
+OVERLOADABLE long16 convert_long16_rtn(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(double16 v);
+OVERLOADABLE int16 convert_int16_rte(double16 v);
+OVERLOADABLE int16 convert_int16_rtz(double16 v);
+OVERLOADABLE int16 convert_int16_rtp(double16 v);
+OVERLOADABLE int16 convert_int16_rtn(double16 v);
+OVERLOADABLE uint16 convert_uint16_rte(double16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(double16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(double16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(double16 v);
+OVERLOADABLE short16 convert_short16_rte(double16 v);
+OVERLOADABLE short16 convert_short16_rtz(double16 v);
+OVERLOADABLE short16 convert_short16_rtp(double16 v);
+OVERLOADABLE short16 convert_short16_rtn(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(double16 v);
+OVERLOADABLE char16 convert_char16_rte(double16 v);
+OVERLOADABLE char16 convert_char16_rtz(double16 v);
+OVERLOADABLE char16 convert_char16_rtp(double16 v);
+OVERLOADABLE char16 convert_char16_rtn(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(double16 v);
+OVERLOADABLE float16 convert_float16_rte(double16 v);
+OVERLOADABLE float16 convert_float16_rtz(double16 v);
+OVERLOADABLE float16 convert_float16_rtp(double16 v);
+OVERLOADABLE float16 convert_float16_rtn(double16 v);
+OVERLOADABLE half16 convert_half16_rte(double16 v);
+OVERLOADABLE half16 convert_half16_rtz(double16 v);
+OVERLOADABLE half16 convert_half16_rtp(double16 v);
+OVERLOADABLE half16 convert_half16_rtn(double16 v);
+OVERLOADABLE long16 convert_long16_rte(float16 v);
+OVERLOADABLE long16 convert_long16_rtz(float16 v);
+OVERLOADABLE long16 convert_long16_rtp(float16 v);
+OVERLOADABLE long16 convert_long16_rtn(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(float16 v);
+OVERLOADABLE int16 convert_int16_rte(float16 v);
+OVERLOADABLE int16 convert_int16_rtz(float16 v);
+OVERLOADABLE int16 convert_int16_rtp(float16 v);
+OVERLOADABLE int16 convert_int16_rtn(float16 v);
+OVERLOADABLE uint16 convert_uint16_rte(float16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(float16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(float16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(float16 v);
+OVERLOADABLE short16 convert_short16_rte(float16 v);
+OVERLOADABLE short16 convert_short16_rtz(float16 v);
+OVERLOADABLE short16 convert_short16_rtp(float16 v);
+OVERLOADABLE short16 convert_short16_rtn(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(float16 v);
+OVERLOADABLE char16 convert_char16_rte(float16 v);
+OVERLOADABLE char16 convert_char16_rtz(float16 v);
+OVERLOADABLE char16 convert_char16_rtp(float16 v);
+OVERLOADABLE char16 convert_char16_rtn(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(float16 v);
+OVERLOADABLE float16 convert_float16_rte(float16 v);
+OVERLOADABLE float16 convert_float16_rtz(float16 v);
+OVERLOADABLE float16 convert_float16_rtp(float16 v);
+OVERLOADABLE float16 convert_float16_rtn(float16 v);
+OVERLOADABLE half16 convert_half16_rte(float16 v);
+OVERLOADABLE half16 convert_half16_rtz(float16 v);
+OVERLOADABLE half16 convert_half16_rtp(float16 v);
+OVERLOADABLE half16 convert_half16_rtn(float16 v);
+OVERLOADABLE long16 convert_long16_rte(half16 v);
+OVERLOADABLE long16 convert_long16_rtz(half16 v);
+OVERLOADABLE long16 convert_long16_rtp(half16 v);
+OVERLOADABLE long16 convert_long16_rtn(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_rte(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtz(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtp(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_rtn(half16 v);
+OVERLOADABLE int16 convert_int16_rte(half16 v);
+OVERLOADABLE int16 convert_int16_rtz(half16 v);
+OVERLOADABLE int16 convert_int16_rtp(half16 v);
+OVERLOADABLE int16 convert_int16_rtn(half16 v);
+OVERLOADABLE uint16 convert_uint16_rte(half16 v);
+OVERLOADABLE uint16 convert_uint16_rtz(half16 v);
+OVERLOADABLE uint16 convert_uint16_rtp(half16 v);
+OVERLOADABLE uint16 convert_uint16_rtn(half16 v);
+OVERLOADABLE short16 convert_short16_rte(half16 v);
+OVERLOADABLE short16 convert_short16_rtz(half16 v);
+OVERLOADABLE short16 convert_short16_rtp(half16 v);
+OVERLOADABLE short16 convert_short16_rtn(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_rte(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtz(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtp(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_rtn(half16 v);
+OVERLOADABLE char16 convert_char16_rte(half16 v);
+OVERLOADABLE char16 convert_char16_rtz(half16 v);
+OVERLOADABLE char16 convert_char16_rtp(half16 v);
+OVERLOADABLE char16 convert_char16_rtn(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_rte(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtz(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtp(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_rtn(half16 v);
+OVERLOADABLE float16 convert_float16_rte(half16 v);
+OVERLOADABLE float16 convert_float16_rtz(half16 v);
+OVERLOADABLE float16 convert_float16_rtp(half16 v);
+OVERLOADABLE float16 convert_float16_rtn(half16 v);
+OVERLOADABLE half16 convert_half16_rte(half16 v);
+OVERLOADABLE half16 convert_half16_rtz(half16 v);
+OVERLOADABLE half16 convert_half16_rtp(half16 v);
+OVERLOADABLE half16 convert_half16_rtn(half16 v);
+#define DEF(DSTTYPE, SRCTYPE, SRC_MIN, SRC_MAX, DST_MIN, DST_MAX)             OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rte(SRCTYPE x);             OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rtz(SRCTYPE x);             OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rtn(SRCTYPE x);             OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rtp(SRCTYPE x);
+
+    DEF(char, double, -0x1.0p7, 0x1.0p7-1,  0x80, 0x7F);
+    DEF(uchar, double, 0, 0x1.0p8-1, 0, 0xFF);
+    DEF(short, double, -0x1.0p15, 0x1.0p15-1, 0x8000, 0x7FFF);
+    DEF(ushort, double, 0, 0x1.0p16-1, 0, 0xFFFF);
+    DEF(int, double, -0x1.0p31, 0x1.0p31-1, 0x80000000, 0x7FFFFFFF);
+    DEF(uint, double, 0, 0x1.0p32-1, 0, 0xFFFFFFFF);
+    DEF(long, double, -0x1.0p63, 0x1.0p63, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF);
+    DEF(ulong, double, 0, 0x1.0p64, 0, 0xFFFFFFFFFFFFFFFF);
+    #undef DEF
+    
+OVERLOADABLE long convert_long_sat_rte(long x);
+OVERLOADABLE long convert_long_sat_rtz(long x);
+OVERLOADABLE long convert_long_sat_rtp(long x);
+OVERLOADABLE long convert_long_sat_rtn(long x);
+OVERLOADABLE ulong convert_ulong_sat_rte(long x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(long x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(long x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(long x);
+OVERLOADABLE int convert_int_sat_rte(long x);
+OVERLOADABLE int convert_int_sat_rtz(long x);
+OVERLOADABLE int convert_int_sat_rtp(long x);
+OVERLOADABLE int convert_int_sat_rtn(long x);
+OVERLOADABLE uint convert_uint_sat_rte(long x);
+OVERLOADABLE uint convert_uint_sat_rtz(long x);
+OVERLOADABLE uint convert_uint_sat_rtp(long x);
+OVERLOADABLE uint convert_uint_sat_rtn(long x);
+OVERLOADABLE short convert_short_sat_rte(long x);
+OVERLOADABLE short convert_short_sat_rtz(long x);
+OVERLOADABLE short convert_short_sat_rtp(long x);
+OVERLOADABLE short convert_short_sat_rtn(long x);
+OVERLOADABLE ushort convert_ushort_sat_rte(long x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(long x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(long x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(long x);
+OVERLOADABLE char convert_char_sat_rte(long x);
+OVERLOADABLE char convert_char_sat_rtz(long x);
+OVERLOADABLE char convert_char_sat_rtp(long x);
+OVERLOADABLE char convert_char_sat_rtn(long x);
+OVERLOADABLE uchar convert_uchar_sat_rte(long x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(long x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(long x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(long x);
+OVERLOADABLE long convert_long_sat_rte(ulong x);
+OVERLOADABLE long convert_long_sat_rtz(ulong x);
+OVERLOADABLE long convert_long_sat_rtp(ulong x);
+OVERLOADABLE long convert_long_sat_rtn(ulong x);
+OVERLOADABLE ulong convert_ulong_sat_rte(ulong x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(ulong x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(ulong x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(ulong x);
+OVERLOADABLE int convert_int_sat_rte(ulong x);
+OVERLOADABLE int convert_int_sat_rtz(ulong x);
+OVERLOADABLE int convert_int_sat_rtp(ulong x);
+OVERLOADABLE int convert_int_sat_rtn(ulong x);
+OVERLOADABLE uint convert_uint_sat_rte(ulong x);
+OVERLOADABLE uint convert_uint_sat_rtz(ulong x);
+OVERLOADABLE uint convert_uint_sat_rtp(ulong x);
+OVERLOADABLE uint convert_uint_sat_rtn(ulong x);
+OVERLOADABLE short convert_short_sat_rte(ulong x);
+OVERLOADABLE short convert_short_sat_rtz(ulong x);
+OVERLOADABLE short convert_short_sat_rtp(ulong x);
+OVERLOADABLE short convert_short_sat_rtn(ulong x);
+OVERLOADABLE ushort convert_ushort_sat_rte(ulong x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(ulong x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(ulong x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(ulong x);
+OVERLOADABLE char convert_char_sat_rte(ulong x);
+OVERLOADABLE char convert_char_sat_rtz(ulong x);
+OVERLOADABLE char convert_char_sat_rtp(ulong x);
+OVERLOADABLE char convert_char_sat_rtn(ulong x);
+OVERLOADABLE uchar convert_uchar_sat_rte(ulong x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(ulong x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(ulong x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(ulong x);
+OVERLOADABLE long convert_long_sat_rte(int x);
+OVERLOADABLE long convert_long_sat_rtz(int x);
+OVERLOADABLE long convert_long_sat_rtp(int x);
+OVERLOADABLE long convert_long_sat_rtn(int x);
+OVERLOADABLE ulong convert_ulong_sat_rte(int x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(int x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(int x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(int x);
+OVERLOADABLE int convert_int_sat_rte(int x);
+OVERLOADABLE int convert_int_sat_rtz(int x);
+OVERLOADABLE int convert_int_sat_rtp(int x);
+OVERLOADABLE int convert_int_sat_rtn(int x);
+OVERLOADABLE uint convert_uint_sat_rte(int x);
+OVERLOADABLE uint convert_uint_sat_rtz(int x);
+OVERLOADABLE uint convert_uint_sat_rtp(int x);
+OVERLOADABLE uint convert_uint_sat_rtn(int x);
+OVERLOADABLE short convert_short_sat_rte(int x);
+OVERLOADABLE short convert_short_sat_rtz(int x);
+OVERLOADABLE short convert_short_sat_rtp(int x);
+OVERLOADABLE short convert_short_sat_rtn(int x);
+OVERLOADABLE ushort convert_ushort_sat_rte(int x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(int x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(int x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(int x);
+OVERLOADABLE char convert_char_sat_rte(int x);
+OVERLOADABLE char convert_char_sat_rtz(int x);
+OVERLOADABLE char convert_char_sat_rtp(int x);
+OVERLOADABLE char convert_char_sat_rtn(int x);
+OVERLOADABLE uchar convert_uchar_sat_rte(int x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(int x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(int x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(int x);
+OVERLOADABLE long convert_long_sat_rte(uint x);
+OVERLOADABLE long convert_long_sat_rtz(uint x);
+OVERLOADABLE long convert_long_sat_rtp(uint x);
+OVERLOADABLE long convert_long_sat_rtn(uint x);
+OVERLOADABLE ulong convert_ulong_sat_rte(uint x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(uint x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(uint x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(uint x);
+OVERLOADABLE int convert_int_sat_rte(uint x);
+OVERLOADABLE int convert_int_sat_rtz(uint x);
+OVERLOADABLE int convert_int_sat_rtp(uint x);
+OVERLOADABLE int convert_int_sat_rtn(uint x);
+OVERLOADABLE uint convert_uint_sat_rte(uint x);
+OVERLOADABLE uint convert_uint_sat_rtz(uint x);
+OVERLOADABLE uint convert_uint_sat_rtp(uint x);
+OVERLOADABLE uint convert_uint_sat_rtn(uint x);
+OVERLOADABLE short convert_short_sat_rte(uint x);
+OVERLOADABLE short convert_short_sat_rtz(uint x);
+OVERLOADABLE short convert_short_sat_rtp(uint x);
+OVERLOADABLE short convert_short_sat_rtn(uint x);
+OVERLOADABLE ushort convert_ushort_sat_rte(uint x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(uint x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(uint x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(uint x);
+OVERLOADABLE char convert_char_sat_rte(uint x);
+OVERLOADABLE char convert_char_sat_rtz(uint x);
+OVERLOADABLE char convert_char_sat_rtp(uint x);
+OVERLOADABLE char convert_char_sat_rtn(uint x);
+OVERLOADABLE uchar convert_uchar_sat_rte(uint x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(uint x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(uint x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(uint x);
+OVERLOADABLE long convert_long_sat_rte(short x);
+OVERLOADABLE long convert_long_sat_rtz(short x);
+OVERLOADABLE long convert_long_sat_rtp(short x);
+OVERLOADABLE long convert_long_sat_rtn(short x);
+OVERLOADABLE ulong convert_ulong_sat_rte(short x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(short x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(short x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(short x);
+OVERLOADABLE int convert_int_sat_rte(short x);
+OVERLOADABLE int convert_int_sat_rtz(short x);
+OVERLOADABLE int convert_int_sat_rtp(short x);
+OVERLOADABLE int convert_int_sat_rtn(short x);
+OVERLOADABLE uint convert_uint_sat_rte(short x);
+OVERLOADABLE uint convert_uint_sat_rtz(short x);
+OVERLOADABLE uint convert_uint_sat_rtp(short x);
+OVERLOADABLE uint convert_uint_sat_rtn(short x);
+OVERLOADABLE short convert_short_sat_rte(short x);
+OVERLOADABLE short convert_short_sat_rtz(short x);
+OVERLOADABLE short convert_short_sat_rtp(short x);
+OVERLOADABLE short convert_short_sat_rtn(short x);
+OVERLOADABLE ushort convert_ushort_sat_rte(short x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(short x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(short x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(short x);
+OVERLOADABLE char convert_char_sat_rte(short x);
+OVERLOADABLE char convert_char_sat_rtz(short x);
+OVERLOADABLE char convert_char_sat_rtp(short x);
+OVERLOADABLE char convert_char_sat_rtn(short x);
+OVERLOADABLE uchar convert_uchar_sat_rte(short x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(short x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(short x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(short x);
+OVERLOADABLE long convert_long_sat_rte(ushort x);
+OVERLOADABLE long convert_long_sat_rtz(ushort x);
+OVERLOADABLE long convert_long_sat_rtp(ushort x);
+OVERLOADABLE long convert_long_sat_rtn(ushort x);
+OVERLOADABLE ulong convert_ulong_sat_rte(ushort x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(ushort x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(ushort x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(ushort x);
+OVERLOADABLE int convert_int_sat_rte(ushort x);
+OVERLOADABLE int convert_int_sat_rtz(ushort x);
+OVERLOADABLE int convert_int_sat_rtp(ushort x);
+OVERLOADABLE int convert_int_sat_rtn(ushort x);
+OVERLOADABLE uint convert_uint_sat_rte(ushort x);
+OVERLOADABLE uint convert_uint_sat_rtz(ushort x);
+OVERLOADABLE uint convert_uint_sat_rtp(ushort x);
+OVERLOADABLE uint convert_uint_sat_rtn(ushort x);
+OVERLOADABLE short convert_short_sat_rte(ushort x);
+OVERLOADABLE short convert_short_sat_rtz(ushort x);
+OVERLOADABLE short convert_short_sat_rtp(ushort x);
+OVERLOADABLE short convert_short_sat_rtn(ushort x);
+OVERLOADABLE ushort convert_ushort_sat_rte(ushort x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(ushort x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(ushort x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(ushort x);
+OVERLOADABLE char convert_char_sat_rte(ushort x);
+OVERLOADABLE char convert_char_sat_rtz(ushort x);
+OVERLOADABLE char convert_char_sat_rtp(ushort x);
+OVERLOADABLE char convert_char_sat_rtn(ushort x);
+OVERLOADABLE uchar convert_uchar_sat_rte(ushort x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(ushort x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(ushort x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(ushort x);
+OVERLOADABLE long convert_long_sat_rte(char x);
+OVERLOADABLE long convert_long_sat_rtz(char x);
+OVERLOADABLE long convert_long_sat_rtp(char x);
+OVERLOADABLE long convert_long_sat_rtn(char x);
+OVERLOADABLE ulong convert_ulong_sat_rte(char x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(char x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(char x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(char x);
+OVERLOADABLE int convert_int_sat_rte(char x);
+OVERLOADABLE int convert_int_sat_rtz(char x);
+OVERLOADABLE int convert_int_sat_rtp(char x);
+OVERLOADABLE int convert_int_sat_rtn(char x);
+OVERLOADABLE uint convert_uint_sat_rte(char x);
+OVERLOADABLE uint convert_uint_sat_rtz(char x);
+OVERLOADABLE uint convert_uint_sat_rtp(char x);
+OVERLOADABLE uint convert_uint_sat_rtn(char x);
+OVERLOADABLE short convert_short_sat_rte(char x);
+OVERLOADABLE short convert_short_sat_rtz(char x);
+OVERLOADABLE short convert_short_sat_rtp(char x);
+OVERLOADABLE short convert_short_sat_rtn(char x);
+OVERLOADABLE ushort convert_ushort_sat_rte(char x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(char x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(char x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(char x);
+OVERLOADABLE char convert_char_sat_rte(char x);
+OVERLOADABLE char convert_char_sat_rtz(char x);
+OVERLOADABLE char convert_char_sat_rtp(char x);
+OVERLOADABLE char convert_char_sat_rtn(char x);
+OVERLOADABLE uchar convert_uchar_sat_rte(char x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(char x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(char x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(char x);
+OVERLOADABLE long convert_long_sat_rte(uchar x);
+OVERLOADABLE long convert_long_sat_rtz(uchar x);
+OVERLOADABLE long convert_long_sat_rtp(uchar x);
+OVERLOADABLE long convert_long_sat_rtn(uchar x);
+OVERLOADABLE ulong convert_ulong_sat_rte(uchar x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(uchar x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(uchar x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(uchar x);
+OVERLOADABLE int convert_int_sat_rte(uchar x);
+OVERLOADABLE int convert_int_sat_rtz(uchar x);
+OVERLOADABLE int convert_int_sat_rtp(uchar x);
+OVERLOADABLE int convert_int_sat_rtn(uchar x);
+OVERLOADABLE uint convert_uint_sat_rte(uchar x);
+OVERLOADABLE uint convert_uint_sat_rtz(uchar x);
+OVERLOADABLE uint convert_uint_sat_rtp(uchar x);
+OVERLOADABLE uint convert_uint_sat_rtn(uchar x);
+OVERLOADABLE short convert_short_sat_rte(uchar x);
+OVERLOADABLE short convert_short_sat_rtz(uchar x);
+OVERLOADABLE short convert_short_sat_rtp(uchar x);
+OVERLOADABLE short convert_short_sat_rtn(uchar x);
+OVERLOADABLE ushort convert_ushort_sat_rte(uchar x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(uchar x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(uchar x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(uchar x);
+OVERLOADABLE char convert_char_sat_rte(uchar x);
+OVERLOADABLE char convert_char_sat_rtz(uchar x);
+OVERLOADABLE char convert_char_sat_rtp(uchar x);
+OVERLOADABLE char convert_char_sat_rtn(uchar x);
+OVERLOADABLE uchar convert_uchar_sat_rte(uchar x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(uchar x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(uchar x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(uchar x);
+OVERLOADABLE long convert_long_sat_rte(float x);
+OVERLOADABLE long convert_long_sat_rtz(float x);
+OVERLOADABLE long convert_long_sat_rtp(float x);
+OVERLOADABLE long convert_long_sat_rtn(float x);
+OVERLOADABLE ulong convert_ulong_sat_rte(float x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(float x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(float x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(float x);
+OVERLOADABLE int convert_int_sat_rte(float x);
+OVERLOADABLE int convert_int_sat_rtz(float x);
+OVERLOADABLE int convert_int_sat_rtp(float x);
+OVERLOADABLE int convert_int_sat_rtn(float x);
+OVERLOADABLE uint convert_uint_sat_rte(float x);
+OVERLOADABLE uint convert_uint_sat_rtz(float x);
+OVERLOADABLE uint convert_uint_sat_rtp(float x);
+OVERLOADABLE uint convert_uint_sat_rtn(float x);
+OVERLOADABLE short convert_short_sat_rte(float x);
+OVERLOADABLE short convert_short_sat_rtz(float x);
+OVERLOADABLE short convert_short_sat_rtp(float x);
+OVERLOADABLE short convert_short_sat_rtn(float x);
+OVERLOADABLE ushort convert_ushort_sat_rte(float x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(float x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(float x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(float x);
+OVERLOADABLE char convert_char_sat_rte(float x);
+OVERLOADABLE char convert_char_sat_rtz(float x);
+OVERLOADABLE char convert_char_sat_rtp(float x);
+OVERLOADABLE char convert_char_sat_rtn(float x);
+OVERLOADABLE uchar convert_uchar_sat_rte(float x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(float x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(float x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(float x);
+OVERLOADABLE long convert_long_sat_rte(half x);
+OVERLOADABLE long convert_long_sat_rtz(half x);
+OVERLOADABLE long convert_long_sat_rtp(half x);
+OVERLOADABLE long convert_long_sat_rtn(half x);
+OVERLOADABLE ulong convert_ulong_sat_rte(half x);
+OVERLOADABLE ulong convert_ulong_sat_rtz(half x);
+OVERLOADABLE ulong convert_ulong_sat_rtp(half x);
+OVERLOADABLE ulong convert_ulong_sat_rtn(half x);
+OVERLOADABLE int convert_int_sat_rte(half x);
+OVERLOADABLE int convert_int_sat_rtz(half x);
+OVERLOADABLE int convert_int_sat_rtp(half x);
+OVERLOADABLE int convert_int_sat_rtn(half x);
+OVERLOADABLE uint convert_uint_sat_rte(half x);
+OVERLOADABLE uint convert_uint_sat_rtz(half x);
+OVERLOADABLE uint convert_uint_sat_rtp(half x);
+OVERLOADABLE uint convert_uint_sat_rtn(half x);
+OVERLOADABLE short convert_short_sat_rte(half x);
+OVERLOADABLE short convert_short_sat_rtz(half x);
+OVERLOADABLE short convert_short_sat_rtp(half x);
+OVERLOADABLE short convert_short_sat_rtn(half x);
+OVERLOADABLE ushort convert_ushort_sat_rte(half x);
+OVERLOADABLE ushort convert_ushort_sat_rtz(half x);
+OVERLOADABLE ushort convert_ushort_sat_rtp(half x);
+OVERLOADABLE ushort convert_ushort_sat_rtn(half x);
+OVERLOADABLE char convert_char_sat_rte(half x);
+OVERLOADABLE char convert_char_sat_rtz(half x);
+OVERLOADABLE char convert_char_sat_rtp(half x);
+OVERLOADABLE char convert_char_sat_rtn(half x);
+OVERLOADABLE uchar convert_uchar_sat_rte(half x);
+OVERLOADABLE uchar convert_uchar_sat_rtz(half x);
+OVERLOADABLE uchar convert_uchar_sat_rtp(half x);
+OVERLOADABLE uchar convert_uchar_sat_rtn(half x);
+OVERLOADABLE long2 convert_long2_sat_rte(long2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(long2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(long2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(long2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(long2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(long2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(long2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(long2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(long2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(long2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(long2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(long2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(long2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(long2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(long2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(long2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(long2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(long2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(long2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(long2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(long2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(long2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(long2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(ulong2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(ulong2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(ulong2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(ulong2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(ulong2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(ulong2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(ulong2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(ulong2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(ulong2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(ulong2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(ulong2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(ulong2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(ulong2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(ulong2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(ulong2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(ulong2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(ulong2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(ulong2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(ulong2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(ulong2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(int2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(int2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(int2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(int2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(int2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(int2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(int2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(int2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(int2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(int2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(int2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(int2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(int2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(int2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(int2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(int2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(int2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(int2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(int2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(int2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(int2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(int2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(int2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(uint2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(uint2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(uint2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(uint2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(uint2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(uint2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(uint2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(uint2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(uint2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(uint2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(uint2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(uint2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(uint2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(uint2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(uint2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(uint2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(uint2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(uint2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(uint2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(uint2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(uint2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(uint2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(uint2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(short2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(short2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(short2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(short2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(short2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(short2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(short2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(short2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(short2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(short2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(short2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(short2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(short2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(short2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(short2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(short2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(short2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(short2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(short2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(short2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(short2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(short2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(short2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(ushort2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(ushort2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(ushort2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(ushort2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(ushort2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(ushort2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(ushort2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(ushort2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(ushort2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(ushort2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(ushort2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(ushort2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(ushort2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(ushort2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(ushort2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(ushort2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(ushort2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(ushort2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(ushort2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(ushort2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(char2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(char2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(char2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(char2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(char2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(char2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(char2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(char2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(char2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(char2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(char2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(char2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(char2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(char2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(char2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(char2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(char2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(char2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(char2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(char2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(char2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(char2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(char2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(uchar2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(uchar2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(uchar2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(uchar2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(uchar2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(uchar2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(uchar2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(uchar2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(uchar2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(uchar2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(uchar2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(uchar2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(uchar2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(uchar2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(uchar2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(uchar2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(uchar2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(uchar2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(uchar2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(uchar2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(double2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(double2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(double2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(double2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(double2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(double2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(double2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(double2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(double2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(double2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(double2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(double2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(double2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(double2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(double2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(double2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(double2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(double2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(double2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(double2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(double2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(double2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(double2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(float2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(float2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(float2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(float2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(float2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(float2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(float2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(float2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(float2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(float2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(float2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(float2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(float2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(float2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(float2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(float2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(float2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(float2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(float2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(float2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(float2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(float2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(float2 v);
+OVERLOADABLE long2 convert_long2_sat_rte(half2 v);
+OVERLOADABLE long2 convert_long2_sat_rtz(half2 v);
+OVERLOADABLE long2 convert_long2_sat_rtp(half2 v);
+OVERLOADABLE long2 convert_long2_sat_rtn(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rte(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtz(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtp(half2 v);
+OVERLOADABLE ulong2 convert_ulong2_sat_rtn(half2 v);
+OVERLOADABLE int2 convert_int2_sat_rte(half2 v);
+OVERLOADABLE int2 convert_int2_sat_rtz(half2 v);
+OVERLOADABLE int2 convert_int2_sat_rtp(half2 v);
+OVERLOADABLE int2 convert_int2_sat_rtn(half2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rte(half2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtz(half2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtp(half2 v);
+OVERLOADABLE uint2 convert_uint2_sat_rtn(half2 v);
+OVERLOADABLE short2 convert_short2_sat_rte(half2 v);
+OVERLOADABLE short2 convert_short2_sat_rtz(half2 v);
+OVERLOADABLE short2 convert_short2_sat_rtp(half2 v);
+OVERLOADABLE short2 convert_short2_sat_rtn(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rte(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtz(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtp(half2 v);
+OVERLOADABLE ushort2 convert_ushort2_sat_rtn(half2 v);
+OVERLOADABLE char2 convert_char2_sat_rte(half2 v);
+OVERLOADABLE char2 convert_char2_sat_rtz(half2 v);
+OVERLOADABLE char2 convert_char2_sat_rtp(half2 v);
+OVERLOADABLE char2 convert_char2_sat_rtn(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rte(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtz(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtp(half2 v);
+OVERLOADABLE uchar2 convert_uchar2_sat_rtn(half2 v);
+OVERLOADABLE long3 convert_long3_sat_rte(long3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(long3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(long3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(long3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(long3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(long3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(long3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(long3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(long3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(long3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(long3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(long3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(long3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(long3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(long3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(long3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(long3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(long3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(long3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(long3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(long3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(long3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(long3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(ulong3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(ulong3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(ulong3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(ulong3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(ulong3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(ulong3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(ulong3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(ulong3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(ulong3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(ulong3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(ulong3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(ulong3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(ulong3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(ulong3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(ulong3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(ulong3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(ulong3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(ulong3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(ulong3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(ulong3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(int3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(int3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(int3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(int3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(int3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(int3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(int3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(int3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(int3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(int3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(int3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(int3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(int3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(int3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(int3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(int3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(int3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(int3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(int3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(int3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(int3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(int3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(int3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(uint3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(uint3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(uint3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(uint3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(uint3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(uint3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(uint3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(uint3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(uint3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(uint3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(uint3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(uint3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(uint3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(uint3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(uint3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(uint3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(uint3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(uint3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(uint3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(uint3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(uint3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(uint3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(uint3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(short3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(short3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(short3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(short3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(short3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(short3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(short3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(short3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(short3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(short3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(short3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(short3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(short3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(short3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(short3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(short3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(short3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(short3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(short3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(short3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(short3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(short3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(short3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(ushort3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(ushort3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(ushort3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(ushort3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(ushort3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(ushort3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(ushort3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(ushort3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(ushort3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(ushort3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(ushort3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(ushort3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(ushort3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(ushort3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(ushort3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(ushort3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(ushort3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(ushort3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(ushort3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(ushort3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(char3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(char3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(char3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(char3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(char3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(char3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(char3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(char3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(char3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(char3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(char3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(char3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(char3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(char3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(char3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(char3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(char3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(char3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(char3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(char3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(char3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(char3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(char3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(uchar3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(uchar3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(uchar3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(uchar3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(uchar3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(uchar3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(uchar3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(uchar3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(uchar3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(uchar3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(uchar3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(uchar3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(uchar3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(uchar3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(uchar3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(uchar3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(uchar3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(uchar3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(uchar3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(uchar3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(double3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(double3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(double3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(double3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(double3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(double3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(double3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(double3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(double3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(double3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(double3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(double3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(double3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(double3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(double3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(double3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(double3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(double3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(double3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(double3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(double3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(double3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(double3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(float3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(float3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(float3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(float3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(float3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(float3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(float3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(float3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(float3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(float3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(float3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(float3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(float3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(float3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(float3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(float3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(float3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(float3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(float3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(float3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(float3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(float3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(float3 v);
+OVERLOADABLE long3 convert_long3_sat_rte(half3 v);
+OVERLOADABLE long3 convert_long3_sat_rtz(half3 v);
+OVERLOADABLE long3 convert_long3_sat_rtp(half3 v);
+OVERLOADABLE long3 convert_long3_sat_rtn(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rte(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtz(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtp(half3 v);
+OVERLOADABLE ulong3 convert_ulong3_sat_rtn(half3 v);
+OVERLOADABLE int3 convert_int3_sat_rte(half3 v);
+OVERLOADABLE int3 convert_int3_sat_rtz(half3 v);
+OVERLOADABLE int3 convert_int3_sat_rtp(half3 v);
+OVERLOADABLE int3 convert_int3_sat_rtn(half3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rte(half3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtz(half3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtp(half3 v);
+OVERLOADABLE uint3 convert_uint3_sat_rtn(half3 v);
+OVERLOADABLE short3 convert_short3_sat_rte(half3 v);
+OVERLOADABLE short3 convert_short3_sat_rtz(half3 v);
+OVERLOADABLE short3 convert_short3_sat_rtp(half3 v);
+OVERLOADABLE short3 convert_short3_sat_rtn(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rte(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtz(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtp(half3 v);
+OVERLOADABLE ushort3 convert_ushort3_sat_rtn(half3 v);
+OVERLOADABLE char3 convert_char3_sat_rte(half3 v);
+OVERLOADABLE char3 convert_char3_sat_rtz(half3 v);
+OVERLOADABLE char3 convert_char3_sat_rtp(half3 v);
+OVERLOADABLE char3 convert_char3_sat_rtn(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rte(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtz(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtp(half3 v);
+OVERLOADABLE uchar3 convert_uchar3_sat_rtn(half3 v);
+OVERLOADABLE long4 convert_long4_sat_rte(long4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(long4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(long4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(long4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(long4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(long4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(long4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(long4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(long4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(long4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(long4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(long4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(long4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(long4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(long4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(long4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(long4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(long4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(long4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(long4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(long4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(long4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(long4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(ulong4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(ulong4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(ulong4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(ulong4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(ulong4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(ulong4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(ulong4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(ulong4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(ulong4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(ulong4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(ulong4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(ulong4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(ulong4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(ulong4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(ulong4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(ulong4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(ulong4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(ulong4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(ulong4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(ulong4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(int4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(int4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(int4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(int4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(int4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(int4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(int4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(int4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(int4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(int4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(int4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(int4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(int4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(int4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(int4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(int4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(int4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(int4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(int4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(int4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(int4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(int4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(int4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(uint4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(uint4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(uint4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(uint4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(uint4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(uint4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(uint4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(uint4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(uint4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(uint4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(uint4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(uint4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(uint4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(uint4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(uint4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(uint4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(uint4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(uint4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(uint4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(uint4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(uint4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(uint4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(uint4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(short4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(short4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(short4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(short4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(short4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(short4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(short4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(short4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(short4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(short4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(short4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(short4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(short4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(short4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(short4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(short4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(short4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(short4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(short4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(short4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(short4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(short4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(short4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(ushort4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(ushort4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(ushort4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(ushort4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(ushort4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(ushort4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(ushort4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(ushort4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(ushort4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(ushort4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(ushort4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(ushort4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(ushort4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(ushort4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(ushort4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(ushort4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(ushort4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(ushort4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(ushort4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(ushort4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(char4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(char4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(char4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(char4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(char4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(char4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(char4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(char4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(char4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(char4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(char4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(char4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(char4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(char4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(char4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(char4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(char4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(char4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(char4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(char4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(char4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(char4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(char4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(uchar4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(uchar4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(uchar4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(uchar4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(uchar4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(uchar4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(uchar4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(uchar4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(uchar4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(uchar4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(uchar4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(uchar4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(uchar4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(uchar4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(uchar4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(uchar4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(uchar4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(uchar4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(uchar4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(uchar4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(double4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(double4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(double4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(double4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(double4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(double4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(double4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(double4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(double4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(double4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(double4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(double4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(double4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(double4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(double4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(double4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(double4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(double4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(double4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(double4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(double4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(double4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(double4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(float4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(float4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(float4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(float4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(float4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(float4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(float4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(float4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(float4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(float4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(float4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(float4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(float4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(float4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(float4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(float4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(float4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(float4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(float4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(float4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(float4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(float4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(float4 v);
+OVERLOADABLE long4 convert_long4_sat_rte(half4 v);
+OVERLOADABLE long4 convert_long4_sat_rtz(half4 v);
+OVERLOADABLE long4 convert_long4_sat_rtp(half4 v);
+OVERLOADABLE long4 convert_long4_sat_rtn(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rte(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtz(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtp(half4 v);
+OVERLOADABLE ulong4 convert_ulong4_sat_rtn(half4 v);
+OVERLOADABLE int4 convert_int4_sat_rte(half4 v);
+OVERLOADABLE int4 convert_int4_sat_rtz(half4 v);
+OVERLOADABLE int4 convert_int4_sat_rtp(half4 v);
+OVERLOADABLE int4 convert_int4_sat_rtn(half4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rte(half4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtz(half4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtp(half4 v);
+OVERLOADABLE uint4 convert_uint4_sat_rtn(half4 v);
+OVERLOADABLE short4 convert_short4_sat_rte(half4 v);
+OVERLOADABLE short4 convert_short4_sat_rtz(half4 v);
+OVERLOADABLE short4 convert_short4_sat_rtp(half4 v);
+OVERLOADABLE short4 convert_short4_sat_rtn(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rte(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtz(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtp(half4 v);
+OVERLOADABLE ushort4 convert_ushort4_sat_rtn(half4 v);
+OVERLOADABLE char4 convert_char4_sat_rte(half4 v);
+OVERLOADABLE char4 convert_char4_sat_rtz(half4 v);
+OVERLOADABLE char4 convert_char4_sat_rtp(half4 v);
+OVERLOADABLE char4 convert_char4_sat_rtn(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rte(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtz(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtp(half4 v);
+OVERLOADABLE uchar4 convert_uchar4_sat_rtn(half4 v);
+OVERLOADABLE long8 convert_long8_sat_rte(long8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(long8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(long8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(long8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(long8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(long8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(long8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(long8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(long8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(long8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(long8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(long8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(long8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(long8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(long8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(long8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(long8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(long8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(long8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(long8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(long8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(long8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(long8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(ulong8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(ulong8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(ulong8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(ulong8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(ulong8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(ulong8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(ulong8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(ulong8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(ulong8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(ulong8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(ulong8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(ulong8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(ulong8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(ulong8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(ulong8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(ulong8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(ulong8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(ulong8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(ulong8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(ulong8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(int8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(int8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(int8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(int8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(int8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(int8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(int8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(int8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(int8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(int8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(int8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(int8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(int8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(int8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(int8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(int8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(int8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(int8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(int8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(int8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(int8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(int8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(int8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(uint8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(uint8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(uint8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(uint8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(uint8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(uint8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(uint8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(uint8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(uint8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(uint8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(uint8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(uint8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(uint8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(uint8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(uint8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(uint8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(uint8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(uint8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(uint8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(uint8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(uint8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(uint8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(uint8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(short8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(short8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(short8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(short8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(short8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(short8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(short8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(short8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(short8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(short8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(short8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(short8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(short8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(short8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(short8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(short8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(short8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(short8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(short8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(short8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(short8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(short8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(short8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(ushort8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(ushort8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(ushort8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(ushort8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(ushort8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(ushort8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(ushort8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(ushort8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(ushort8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(ushort8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(ushort8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(ushort8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(ushort8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(ushort8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(ushort8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(ushort8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(ushort8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(ushort8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(ushort8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(ushort8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(char8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(char8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(char8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(char8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(char8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(char8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(char8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(char8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(char8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(char8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(char8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(char8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(char8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(char8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(char8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(char8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(char8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(char8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(char8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(char8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(char8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(char8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(char8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(uchar8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(uchar8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(uchar8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(uchar8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(uchar8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(uchar8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(uchar8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(uchar8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(uchar8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(uchar8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(uchar8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(uchar8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(uchar8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(uchar8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(uchar8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(uchar8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(uchar8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(uchar8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(uchar8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(uchar8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(double8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(double8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(double8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(double8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(double8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(double8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(double8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(double8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(double8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(double8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(double8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(double8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(double8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(double8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(double8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(double8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(double8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(double8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(double8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(double8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(double8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(double8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(double8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(float8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(float8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(float8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(float8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(float8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(float8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(float8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(float8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(float8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(float8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(float8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(float8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(float8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(float8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(float8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(float8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(float8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(float8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(float8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(float8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(float8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(float8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(float8 v);
+OVERLOADABLE long8 convert_long8_sat_rte(half8 v);
+OVERLOADABLE long8 convert_long8_sat_rtz(half8 v);
+OVERLOADABLE long8 convert_long8_sat_rtp(half8 v);
+OVERLOADABLE long8 convert_long8_sat_rtn(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rte(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtz(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtp(half8 v);
+OVERLOADABLE ulong8 convert_ulong8_sat_rtn(half8 v);
+OVERLOADABLE int8 convert_int8_sat_rte(half8 v);
+OVERLOADABLE int8 convert_int8_sat_rtz(half8 v);
+OVERLOADABLE int8 convert_int8_sat_rtp(half8 v);
+OVERLOADABLE int8 convert_int8_sat_rtn(half8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rte(half8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtz(half8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtp(half8 v);
+OVERLOADABLE uint8 convert_uint8_sat_rtn(half8 v);
+OVERLOADABLE short8 convert_short8_sat_rte(half8 v);
+OVERLOADABLE short8 convert_short8_sat_rtz(half8 v);
+OVERLOADABLE short8 convert_short8_sat_rtp(half8 v);
+OVERLOADABLE short8 convert_short8_sat_rtn(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rte(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtz(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtp(half8 v);
+OVERLOADABLE ushort8 convert_ushort8_sat_rtn(half8 v);
+OVERLOADABLE char8 convert_char8_sat_rte(half8 v);
+OVERLOADABLE char8 convert_char8_sat_rtz(half8 v);
+OVERLOADABLE char8 convert_char8_sat_rtp(half8 v);
+OVERLOADABLE char8 convert_char8_sat_rtn(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rte(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtz(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtp(half8 v);
+OVERLOADABLE uchar8 convert_uchar8_sat_rtn(half8 v);
+OVERLOADABLE long16 convert_long16_sat_rte(long16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(long16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(long16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(long16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(long16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(long16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(long16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(long16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(long16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(long16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(long16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(long16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(long16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(long16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(long16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(long16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(long16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(long16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(long16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(long16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(long16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(long16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(long16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(ulong16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(ulong16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(ulong16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(ulong16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(ulong16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(ulong16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(ulong16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(ulong16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(ulong16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(ulong16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(ulong16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(ulong16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(ulong16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(ulong16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(ulong16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(ulong16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(ulong16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(ulong16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(ulong16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(ulong16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(int16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(int16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(int16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(int16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(int16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(int16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(int16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(int16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(int16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(int16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(int16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(int16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(int16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(int16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(int16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(int16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(int16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(int16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(int16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(int16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(int16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(int16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(int16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(uint16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(uint16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(uint16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(uint16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(uint16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(uint16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(uint16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(uint16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(uint16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(uint16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(uint16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(uint16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(uint16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(uint16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(uint16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(uint16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(uint16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(uint16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(uint16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(uint16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(uint16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(uint16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(uint16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(short16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(short16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(short16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(short16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(short16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(short16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(short16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(short16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(short16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(short16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(short16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(short16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(short16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(short16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(short16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(short16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(short16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(short16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(short16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(short16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(short16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(short16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(short16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(ushort16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(ushort16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(ushort16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(ushort16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(ushort16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(ushort16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(ushort16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(ushort16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(ushort16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(ushort16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(ushort16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(ushort16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(ushort16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(ushort16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(ushort16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(ushort16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(ushort16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(ushort16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(ushort16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(ushort16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(char16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(char16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(char16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(char16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(char16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(char16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(char16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(char16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(char16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(char16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(char16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(char16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(char16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(char16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(char16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(char16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(char16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(char16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(char16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(char16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(char16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(char16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(char16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(uchar16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(uchar16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(uchar16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(uchar16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(uchar16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(uchar16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(uchar16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(uchar16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(uchar16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(uchar16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(uchar16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(uchar16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(uchar16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(uchar16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(uchar16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(uchar16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(uchar16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(uchar16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(uchar16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(uchar16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(double16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(double16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(double16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(double16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(double16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(double16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(double16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(double16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(double16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(double16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(double16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(double16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(double16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(double16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(double16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(double16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(double16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(double16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(double16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(double16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(double16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(double16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(double16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(float16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(float16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(float16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(float16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(float16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(float16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(float16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(float16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(float16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(float16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(float16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(float16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(float16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(float16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(float16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(float16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(float16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(float16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(float16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(float16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(float16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(float16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(float16 v);
+OVERLOADABLE long16 convert_long16_sat_rte(half16 v);
+OVERLOADABLE long16 convert_long16_sat_rtz(half16 v);
+OVERLOADABLE long16 convert_long16_sat_rtp(half16 v);
+OVERLOADABLE long16 convert_long16_sat_rtn(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rte(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtz(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtp(half16 v);
+OVERLOADABLE ulong16 convert_ulong16_sat_rtn(half16 v);
+OVERLOADABLE int16 convert_int16_sat_rte(half16 v);
+OVERLOADABLE int16 convert_int16_sat_rtz(half16 v);
+OVERLOADABLE int16 convert_int16_sat_rtp(half16 v);
+OVERLOADABLE int16 convert_int16_sat_rtn(half16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rte(half16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtz(half16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtp(half16 v);
+OVERLOADABLE uint16 convert_uint16_sat_rtn(half16 v);
+OVERLOADABLE short16 convert_short16_sat_rte(half16 v);
+OVERLOADABLE short16 convert_short16_sat_rtz(half16 v);
+OVERLOADABLE short16 convert_short16_sat_rtp(half16 v);
+OVERLOADABLE short16 convert_short16_sat_rtn(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rte(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtz(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtp(half16 v);
+OVERLOADABLE ushort16 convert_ushort16_sat_rtn(half16 v);
+OVERLOADABLE char16 convert_char16_sat_rte(half16 v);
+OVERLOADABLE char16 convert_char16_sat_rtz(half16 v);
+OVERLOADABLE char16 convert_char16_sat_rtp(half16 v);
+OVERLOADABLE char16 convert_char16_sat_rtn(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rte(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtz(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtp(half16 v);
+OVERLOADABLE uchar16 convert_uchar16_sat_rtn(half16 v);
+OVERLOADABLE double convert_double_rte(double x);
+OVERLOADABLE double convert_double_rtz(double x);
+OVERLOADABLE double convert_double_rtp(double x);
+OVERLOADABLE double convert_double_rtn(double x);
+OVERLOADABLE double convert_double_rte(float x);
+OVERLOADABLE double convert_double_rtz(float x);
+OVERLOADABLE double convert_double_rtp(float x);
+OVERLOADABLE double convert_double_rtn(float x);
+OVERLOADABLE double convert_double_rte(int x);
+OVERLOADABLE double convert_double_rtz(int x);
+OVERLOADABLE double convert_double_rtp(int x);
+OVERLOADABLE double convert_double_rtn(int x);
+OVERLOADABLE double convert_double_rte(uint x);
+OVERLOADABLE double convert_double_rtz(uint x);
+OVERLOADABLE double convert_double_rtp(uint x);
+OVERLOADABLE double convert_double_rtn(uint x);
+OVERLOADABLE double convert_double_rte(short x);
+OVERLOADABLE double convert_double_rtz(short x);
+OVERLOADABLE double convert_double_rtp(short x);
+OVERLOADABLE double convert_double_rtn(short x);
+OVERLOADABLE double convert_double_rte(ushort x);
+OVERLOADABLE double convert_double_rtz(ushort x);
+OVERLOADABLE double convert_double_rtp(ushort x);
+OVERLOADABLE double convert_double_rtn(ushort x);
+OVERLOADABLE double convert_double_rte(char x);
+OVERLOADABLE double convert_double_rtz(char x);
+OVERLOADABLE double convert_double_rtp(char x);
+OVERLOADABLE double convert_double_rtn(char x);
+OVERLOADABLE double convert_double_rte(uchar x);
+OVERLOADABLE double convert_double_rtz(uchar x);
+OVERLOADABLE double convert_double_rtp(uchar x);
+OVERLOADABLE double convert_double_rtn(uchar x);
+OVERLOADABLE double2 convert_double2_rte(double2 v);
+OVERLOADABLE double2 convert_double2_rtz(double2 v);
+OVERLOADABLE double2 convert_double2_rtp(double2 v);
+OVERLOADABLE double2 convert_double2_rtn(double2 v);
+OVERLOADABLE double2 convert_double2_rte(float2 v);
+OVERLOADABLE double2 convert_double2_rtz(float2 v);
+OVERLOADABLE double2 convert_double2_rtp(float2 v);
+OVERLOADABLE double2 convert_double2_rtn(float2 v);
+OVERLOADABLE double2 convert_double2_rte(int2 v);
+OVERLOADABLE double2 convert_double2_rtz(int2 v);
+OVERLOADABLE double2 convert_double2_rtp(int2 v);
+OVERLOADABLE double2 convert_double2_rtn(int2 v);
+OVERLOADABLE double2 convert_double2_rte(uint2 v);
+OVERLOADABLE double2 convert_double2_rtz(uint2 v);
+OVERLOADABLE double2 convert_double2_rtp(uint2 v);
+OVERLOADABLE double2 convert_double2_rtn(uint2 v);
+OVERLOADABLE double2 convert_double2_rte(short2 v);
+OVERLOADABLE double2 convert_double2_rtz(short2 v);
+OVERLOADABLE double2 convert_double2_rtp(short2 v);
+OVERLOADABLE double2 convert_double2_rtn(short2 v);
+OVERLOADABLE double2 convert_double2_rte(ushort2 v);
+OVERLOADABLE double2 convert_double2_rtz(ushort2 v);
+OVERLOADABLE double2 convert_double2_rtp(ushort2 v);
+OVERLOADABLE double2 convert_double2_rtn(ushort2 v);
+OVERLOADABLE double2 convert_double2_rte(char2 v);
+OVERLOADABLE double2 convert_double2_rtz(char2 v);
+OVERLOADABLE double2 convert_double2_rtp(char2 v);
+OVERLOADABLE double2 convert_double2_rtn(char2 v);
+OVERLOADABLE double2 convert_double2_rte(uchar2 v);
+OVERLOADABLE double2 convert_double2_rtz(uchar2 v);
+OVERLOADABLE double2 convert_double2_rtp(uchar2 v);
+OVERLOADABLE double2 convert_double2_rtn(uchar2 v);
+OVERLOADABLE double3 convert_double3_rte(double3 v);
+OVERLOADABLE double3 convert_double3_rtz(double3 v);
+OVERLOADABLE double3 convert_double3_rtp(double3 v);
+OVERLOADABLE double3 convert_double3_rtn(double3 v);
+OVERLOADABLE double3 convert_double3_rte(float3 v);
+OVERLOADABLE double3 convert_double3_rtz(float3 v);
+OVERLOADABLE double3 convert_double3_rtp(float3 v);
+OVERLOADABLE double3 convert_double3_rtn(float3 v);
+OVERLOADABLE double3 convert_double3_rte(int3 v);
+OVERLOADABLE double3 convert_double3_rtz(int3 v);
+OVERLOADABLE double3 convert_double3_rtp(int3 v);
+OVERLOADABLE double3 convert_double3_rtn(int3 v);
+OVERLOADABLE double3 convert_double3_rte(uint3 v);
+OVERLOADABLE double3 convert_double3_rtz(uint3 v);
+OVERLOADABLE double3 convert_double3_rtp(uint3 v);
+OVERLOADABLE double3 convert_double3_rtn(uint3 v);
+OVERLOADABLE double3 convert_double3_rte(short3 v);
+OVERLOADABLE double3 convert_double3_rtz(short3 v);
+OVERLOADABLE double3 convert_double3_rtp(short3 v);
+OVERLOADABLE double3 convert_double3_rtn(short3 v);
+OVERLOADABLE double3 convert_double3_rte(ushort3 v);
+OVERLOADABLE double3 convert_double3_rtz(ushort3 v);
+OVERLOADABLE double3 convert_double3_rtp(ushort3 v);
+OVERLOADABLE double3 convert_double3_rtn(ushort3 v);
+OVERLOADABLE double3 convert_double3_rte(char3 v);
+OVERLOADABLE double3 convert_double3_rtz(char3 v);
+OVERLOADABLE double3 convert_double3_rtp(char3 v);
+OVERLOADABLE double3 convert_double3_rtn(char3 v);
+OVERLOADABLE double3 convert_double3_rte(uchar3 v);
+OVERLOADABLE double3 convert_double3_rtz(uchar3 v);
+OVERLOADABLE double3 convert_double3_rtp(uchar3 v);
+OVERLOADABLE double3 convert_double3_rtn(uchar3 v);
+OVERLOADABLE double4 convert_double4_rte(double4 v);
+OVERLOADABLE double4 convert_double4_rtz(double4 v);
+OVERLOADABLE double4 convert_double4_rtp(double4 v);
+OVERLOADABLE double4 convert_double4_rtn(double4 v);
+OVERLOADABLE double4 convert_double4_rte(float4 v);
+OVERLOADABLE double4 convert_double4_rtz(float4 v);
+OVERLOADABLE double4 convert_double4_rtp(float4 v);
+OVERLOADABLE double4 convert_double4_rtn(float4 v);
+OVERLOADABLE double4 convert_double4_rte(int4 v);
+OVERLOADABLE double4 convert_double4_rtz(int4 v);
+OVERLOADABLE double4 convert_double4_rtp(int4 v);
+OVERLOADABLE double4 convert_double4_rtn(int4 v);
+OVERLOADABLE double4 convert_double4_rte(uint4 v);
+OVERLOADABLE double4 convert_double4_rtz(uint4 v);
+OVERLOADABLE double4 convert_double4_rtp(uint4 v);
+OVERLOADABLE double4 convert_double4_rtn(uint4 v);
+OVERLOADABLE double4 convert_double4_rte(short4 v);
+OVERLOADABLE double4 convert_double4_rtz(short4 v);
+OVERLOADABLE double4 convert_double4_rtp(short4 v);
+OVERLOADABLE double4 convert_double4_rtn(short4 v);
+OVERLOADABLE double4 convert_double4_rte(ushort4 v);
+OVERLOADABLE double4 convert_double4_rtz(ushort4 v);
+OVERLOADABLE double4 convert_double4_rtp(ushort4 v);
+OVERLOADABLE double4 convert_double4_rtn(ushort4 v);
+OVERLOADABLE double4 convert_double4_rte(char4 v);
+OVERLOADABLE double4 convert_double4_rtz(char4 v);
+OVERLOADABLE double4 convert_double4_rtp(char4 v);
+OVERLOADABLE double4 convert_double4_rtn(char4 v);
+OVERLOADABLE double4 convert_double4_rte(uchar4 v);
+OVERLOADABLE double4 convert_double4_rtz(uchar4 v);
+OVERLOADABLE double4 convert_double4_rtp(uchar4 v);
+OVERLOADABLE double4 convert_double4_rtn(uchar4 v);
+OVERLOADABLE double8 convert_double8_rte(double8 v);
+OVERLOADABLE double8 convert_double8_rtz(double8 v);
+OVERLOADABLE double8 convert_double8_rtp(double8 v);
+OVERLOADABLE double8 convert_double8_rtn(double8 v);
+OVERLOADABLE double8 convert_double8_rte(float8 v);
+OVERLOADABLE double8 convert_double8_rtz(float8 v);
+OVERLOADABLE double8 convert_double8_rtp(float8 v);
+OVERLOADABLE double8 convert_double8_rtn(float8 v);
+OVERLOADABLE double8 convert_double8_rte(int8 v);
+OVERLOADABLE double8 convert_double8_rtz(int8 v);
+OVERLOADABLE double8 convert_double8_rtp(int8 v);
+OVERLOADABLE double8 convert_double8_rtn(int8 v);
+OVERLOADABLE double8 convert_double8_rte(uint8 v);
+OVERLOADABLE double8 convert_double8_rtz(uint8 v);
+OVERLOADABLE double8 convert_double8_rtp(uint8 v);
+OVERLOADABLE double8 convert_double8_rtn(uint8 v);
+OVERLOADABLE double8 convert_double8_rte(short8 v);
+OVERLOADABLE double8 convert_double8_rtz(short8 v);
+OVERLOADABLE double8 convert_double8_rtp(short8 v);
+OVERLOADABLE double8 convert_double8_rtn(short8 v);
+OVERLOADABLE double8 convert_double8_rte(ushort8 v);
+OVERLOADABLE double8 convert_double8_rtz(ushort8 v);
+OVERLOADABLE double8 convert_double8_rtp(ushort8 v);
+OVERLOADABLE double8 convert_double8_rtn(ushort8 v);
+OVERLOADABLE double8 convert_double8_rte(char8 v);
+OVERLOADABLE double8 convert_double8_rtz(char8 v);
+OVERLOADABLE double8 convert_double8_rtp(char8 v);
+OVERLOADABLE double8 convert_double8_rtn(char8 v);
+OVERLOADABLE double8 convert_double8_rte(uchar8 v);
+OVERLOADABLE double8 convert_double8_rtz(uchar8 v);
+OVERLOADABLE double8 convert_double8_rtp(uchar8 v);
+OVERLOADABLE double8 convert_double8_rtn(uchar8 v);
+OVERLOADABLE double16 convert_double16_rte(double16 v);
+OVERLOADABLE double16 convert_double16_rtz(double16 v);
+OVERLOADABLE double16 convert_double16_rtp(double16 v);
+OVERLOADABLE double16 convert_double16_rtn(double16 v);
+OVERLOADABLE double16 convert_double16_rte(float16 v);
+OVERLOADABLE double16 convert_double16_rtz(float16 v);
+OVERLOADABLE double16 convert_double16_rtp(float16 v);
+OVERLOADABLE double16 convert_double16_rtn(float16 v);
+OVERLOADABLE double16 convert_double16_rte(int16 v);
+OVERLOADABLE double16 convert_double16_rtz(int16 v);
+OVERLOADABLE double16 convert_double16_rtp(int16 v);
+OVERLOADABLE double16 convert_double16_rtn(int16 v);
+OVERLOADABLE double16 convert_double16_rte(uint16 v);
+OVERLOADABLE double16 convert_double16_rtz(uint16 v);
+OVERLOADABLE double16 convert_double16_rtp(uint16 v);
+OVERLOADABLE double16 convert_double16_rtn(uint16 v);
+OVERLOADABLE double16 convert_double16_rte(short16 v);
+OVERLOADABLE double16 convert_double16_rtz(short16 v);
+OVERLOADABLE double16 convert_double16_rtp(short16 v);
+OVERLOADABLE double16 convert_double16_rtn(short16 v);
+OVERLOADABLE double16 convert_double16_rte(ushort16 v);
+OVERLOADABLE double16 convert_double16_rtz(ushort16 v);
+OVERLOADABLE double16 convert_double16_rtp(ushort16 v);
+OVERLOADABLE double16 convert_double16_rtn(ushort16 v);
+OVERLOADABLE double16 convert_double16_rte(char16 v);
+OVERLOADABLE double16 convert_double16_rtz(char16 v);
+OVERLOADABLE double16 convert_double16_rtp(char16 v);
+OVERLOADABLE double16 convert_double16_rtn(char16 v);
+OVERLOADABLE double16 convert_double16_rte(uchar16 v);
+OVERLOADABLE double16 convert_double16_rtz(uchar16 v);
+OVERLOADABLE double16 convert_double16_rtp(uchar16 v);
+OVERLOADABLE double16 convert_double16_rtn(uchar16 v);
+OVERLOADABLE double convert_double_rte(ulong x);
+OVERLOADABLE double convert_double_rtz(ulong x);
+OVERLOADABLE double convert_double_rtp(ulong x);
+OVERLOADABLE double convert_double_rtn(ulong x);
+OVERLOADABLE double convert_double_rte(long x);
+OVERLOADABLE double convert_double_rtz(long x);
+OVERLOADABLE double convert_double_rtp(long x);
+OVERLOADABLE double convert_double_rtn(long x);
+OVERLOADABLE double2 convert_double2_rte(ulong2 v);
+OVERLOADABLE double2 convert_double2_rtz(ulong2 v);
+OVERLOADABLE double2 convert_double2_rtp(ulong2 v);
+OVERLOADABLE double2 convert_double2_rtn(ulong2 v);
+OVERLOADABLE double2 convert_double2_rte(long2 v);
+OVERLOADABLE double2 convert_double2_rtz(long2 v);
+OVERLOADABLE double2 convert_double2_rtp(long2 v);
+OVERLOADABLE double2 convert_double2_rtn(long2 v);
+OVERLOADABLE double3 convert_double3_rte(ulong3 v);
+OVERLOADABLE double3 convert_double3_rtz(ulong3 v);
+OVERLOADABLE double3 convert_double3_rtp(ulong3 v);
+OVERLOADABLE double3 convert_double3_rtn(ulong3 v);
+OVERLOADABLE double3 convert_double3_rte(long3 v);
+OVERLOADABLE double3 convert_double3_rtz(long3 v);
+OVERLOADABLE double3 convert_double3_rtp(long3 v);
+OVERLOADABLE double3 convert_double3_rtn(long3 v);
+OVERLOADABLE double4 convert_double4_rte(ulong4 v);
+OVERLOADABLE double4 convert_double4_rtz(ulong4 v);
+OVERLOADABLE double4 convert_double4_rtp(ulong4 v);
+OVERLOADABLE double4 convert_double4_rtn(ulong4 v);
+OVERLOADABLE double4 convert_double4_rte(long4 v);
+OVERLOADABLE double4 convert_double4_rtz(long4 v);
+OVERLOADABLE double4 convert_double4_rtp(long4 v);
+OVERLOADABLE double4 convert_double4_rtn(long4 v);
+OVERLOADABLE double8 convert_double8_rte(ulong8 v);
+OVERLOADABLE double8 convert_double8_rtz(ulong8 v);
+OVERLOADABLE double8 convert_double8_rtp(ulong8 v);
+OVERLOADABLE double8 convert_double8_rtn(ulong8 v);
+OVERLOADABLE double8 convert_double8_rte(long8 v);
+OVERLOADABLE double8 convert_double8_rtz(long8 v);
+OVERLOADABLE double8 convert_double8_rtp(long8 v);
+OVERLOADABLE double8 convert_double8_rtn(long8 v);
+OVERLOADABLE double16 convert_double16_rte(ulong16 v);
+OVERLOADABLE double16 convert_double16_rtz(ulong16 v);
+OVERLOADABLE double16 convert_double16_rtp(ulong16 v);
+OVERLOADABLE double16 convert_double16_rtn(ulong16 v);
+OVERLOADABLE double16 convert_double16_rte(long16 v);
+OVERLOADABLE double16 convert_double16_rtz(long16 v);
+OVERLOADABLE double16 convert_double16_rtp(long16 v);
+OVERLOADABLE double16 convert_double16_rtn(long16 v);
+#endif /* __OCL_CONVERT_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_defines.h b/drivers/pocl-gen7/lib/beignet/include/ocl_defines.h
new file mode 100644
index 0000000..1e030d2
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_defines.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_COMMON_DEF_H__
+#define __OCL_COMMON_DEF_H__
+
+#define __CL_VERSION_1_0__ 100
+#define __CL_VERSION_1_1__ 110
+#define __CL_VERSION_1_2__ 120
+#define CL_VERSION_1_0 100
+#define CL_VERSION_1_1 110
+#define CL_VERSION_1_2 120
+#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300)
+#define __OPENCL_VERSION__ 200
+#define CL_VERSION_2_0 200
+#elif (__OPENCL_C_VERSION__ >= 300)
+/* OpenCL C 3.0 with none of the optional 2.0 features: the 1.2 library */
+#define __OPENCL_VERSION__ 300
+#define CL_VERSION_2_0 200
+#define CL_VERSION_3_0 300
+#else
+#define __OPENCL_VERSION__ 120
+#endif
+#define __ENDIAN_LITTLE__ 1
+#define __IMAGE_SUPPORT__ 1
+#define __kernel_exec(X, TYPE) __kernel __attribute__((work_group_size_hint(X,1,1))) \
+                                        __attribute__((vec_type_hint(TYPE)))
+#define kernel_exec(X, TYPE) __kernel_exec(X, TYPE)
+
+#endif /* end of __OCL_COMMON_DEF_H__ */
+// This file includes defines that are common to both kernel code and
+// the NVPTX back-end.
+#ifndef __OCL_COMMON_DEFINES__
+#define __OCL_COMMON_DEFINES__
+//
+// Common defines for Image intrinsics
+// Channel order
+#define CLK_HAS_ALPHA(color) (color == CLK_A || color == CLK_RA || color == CLK_RGBA || color == CLK_BGRA || color == CLK_ARGB || color == CLK_sRGBA || color == CLK_sBGRA)
+enum {
+  CLK_R = 0x10B0,
+  CLK_A = 0x10B1,
+  CLK_RG = 0x10B2,
+  CLK_RA = 0x10B3,
+  CLK_RGB = 0x10B4,
+  CLK_RGBA = 0x10B5,
+  CLK_BGRA = 0x10B6,
+  CLK_ARGB = 0x10B7,
+
+#if (__NV_CL_C_VERSION == __NV_CL_C_VERSION_1_0)
+  CLK_xRGB = 0x10B7,
+#endif
+
+  CLK_INTENSITY = 0x10B8,
+  CLK_LUMINANCE = 0x10B9
+
+#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_1_1)
+  ,
+  CLK_Rx = 0x10BA,
+  CLK_RGx = 0x10BB,
+  CLK_RGBx = 0x10BC
+#endif
+#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_2_0)
+  ,
+  CLK_sRGBA = 0x10C1,
+  CLK_sBGRA = 0x10C2
+#endif
+};
+
+
+typedef enum clk_channel_type {
+  // valid formats for float return types
+  CLK_SNORM_INT8 = 0x10D0,            // four channel RGBA unorm8
+  CLK_SNORM_INT16 = 0x10D1,           // four channel RGBA unorm16
+  CLK_UNORM_INT8 = 0x10D2,            // four channel RGBA unorm8
+  CLK_UNORM_INT16 = 0x10D3,           // four channel RGBA unorm16
+  CLK_HALF_FLOAT = 0x10DD,            // four channel RGBA half
+  CLK_FLOAT = 0x10DE,                 // four channel RGBA float
+
+#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_1_1)
+  CLK_UNORM_SHORT_565 = 0x10D4,
+  CLK_UNORM_SHORT_555 = 0x10D5,
+  CLK_UNORM_INT_101010 = 0x10D6,
+#endif
+
+  // valid only for integer return types
+  CLK_SIGNED_INT8 =  0x10D7,
+  CLK_SIGNED_INT16 = 0x10D8,
+  CLK_SIGNED_INT32 = 0x10D9,
+  CLK_UNSIGNED_INT8 = 0x10DA,
+  CLK_UNSIGNED_INT16 = 0x10DB,
+  CLK_UNSIGNED_INT32 = 0x10DC,
+
+  // CI SPI for CPU
+  __CLK_UNORM_INT8888 ,         // four channel ARGB unorm8
+  __CLK_UNORM_INT8888R,        // four channel BGRA unorm8
+
+  __CLK_VALID_IMAGE_TYPE_COUNT,
+  __CLK_INVALID_IMAGE_TYPE = __CLK_VALID_IMAGE_TYPE_COUNT,
+  __CLK_VALID_IMAGE_TYPE_MASK_BITS = 4,         // number of bits required to
+                                                // represent any image type
+  __CLK_VALID_IMAGE_TYPE_MASK = ( 1 << __CLK_VALID_IMAGE_TYPE_MASK_BITS ) - 1
+}clk_channel_type;
+
+typedef enum clk_sampler_type {
+    __CLK_NORMALIZED_BASE          = 0,
+    CLK_NORMALIZED_COORDS_FALSE    = 0,
+    CLK_NORMALIZED_COORDS_TRUE     = (1 << __CLK_NORMALIZED_BASE),
+    __CLK_NORMALIZED_MASK          = (CLK_NORMALIZED_COORDS_FALSE |
+                                      CLK_NORMALIZED_COORDS_TRUE),
+    __CLK_NORMALIZED_BITS          = 1,        // number of bits required to
+                                               // represent normalization
+    __CLK_ADDRESS_BASE             = 0,
+    CLK_ADDRESS_NONE               = (0 << __CLK_ADDRESS_BASE),
+    CLK_ADDRESS_CLAMP_TO_EDGE      = (2 << __CLK_ADDRESS_BASE),
+    CLK_ADDRESS_CLAMP              = (4 << __CLK_ADDRESS_BASE),
+    CLK_ADDRESS_REPEAT             = (6 << __CLK_ADDRESS_BASE),
+    CLK_ADDRESS_MIRROR             = (8 << __CLK_ADDRESS_BASE),
+
+#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_1_1)
+    CLK_ADDRESS_MIRRORED_REPEAT    = CLK_ADDRESS_MIRROR,
+#endif
+    __CLK_ADDRESS_MASK             = (CLK_ADDRESS_NONE | CLK_ADDRESS_CLAMP |
+                                     CLK_ADDRESS_CLAMP_TO_EDGE |
+                                     CLK_ADDRESS_REPEAT | CLK_ADDRESS_MIRROR),
+    __CLK_ADDRESS_BITS             = 4,        // number of bits required to
+                                               // represent address info
+    __CLK_FILTER_BASE              = (__CLK_ADDRESS_BASE +  __CLK_ADDRESS_BITS),
+    CLK_FILTER_ANISOTROPIC         = (0 << __CLK_FILTER_BASE),
+    CLK_FILTER_NEAREST             = (1 << __CLK_FILTER_BASE),
+    CLK_FILTER_LINEAR              = (2 << __CLK_FILTER_BASE),
+    __CLK_FILTER_MASK              = (CLK_FILTER_NEAREST | CLK_FILTER_LINEAR |
+                                     CLK_FILTER_ANISOTROPIC),
+    __CLK_FILTER_BITS              = 2,        // number of bits required to
+                                               // represent address info
+
+    __CLK_MIP_BASE                 = (__CLK_FILTER_BASE + __CLK_FILTER_BITS),
+    CLK_MIP_NEAREST                = (0 << __CLK_MIP_BASE),
+    CLK_MIP_LINEAR                 = (1 << __CLK_MIP_BASE),
+    CLK_MIP_ANISOTROPIC            = (2 << __CLK_MIP_BASE),
+    __CLK_MIP_MASK                 = (CLK_MIP_NEAREST | CLK_MIP_LINEAR |
+                                     CLK_MIP_ANISOTROPIC),
+    __CLK_MIP_BITS                 = 2,
+
+    __CLK_SAMPLER_BITS             = (__CLK_MIP_BASE + __CLK_MIP_BITS),
+    __CLK_SAMPLER_MASK             = (__CLK_MIP_MASK | __CLK_FILTER_MASK |
+                                      __CLK_NORMALIZED_MASK | __CLK_ADDRESS_MASK),
+
+    __CLK_SAMPLER_ARG_BASE         = (__CLK_MIP_BASE + __CLK_SAMPLER_BITS),
+    __CLK_SAMPLER_ARG_BITS         = 8,
+    __CLK_SAMPLER_ARG_MASK         = (((1 << __CLK_SAMPLER_ARG_BITS) - 1) << __CLK_SAMPLER_ARG_BASE),
+    __CLK_SAMPLER_ARG_KEY_BIT      = (1 << (__CLK_SAMPLER_ARG_BASE + __CLK_SAMPLER_ARG_BITS)),
+    __CLK_SAMPLER_ARG_KEY_BITS     = 1,
+
+} clk_sampler_type;
+
+#endif   /* __OCL_COMMON_DEFINES__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_enqueue.h b/drivers/pocl-gen7/lib/beignet/include/ocl_enqueue.h
new file mode 100644
index 0000000..8e9fd32
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_enqueue.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __OCL_ENQUEUE_H__
+#define __OCL_ENQUEUE_H__
+
+#include "ocl_types.h"
+#define CLK_ENQUEUE_FLAGS_WAIT_KERNEL 0
+#define CLK_ENQUEUE_FLAGS_NO_WAIT 1
+#define CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP 2
+#define CLK_SUCCESS 0
+#define CL_COMPLETE 0
+#define CLK_PROFILING_COMMAND_EXEC_TIME 0
+
+struct ndrange_info_t {
+  int type;
+  int global_work_size[3];
+  int local_work_size[3];
+  int global_work_offset[3];
+};
+
+struct Block_literal {
+  void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
+  int flags;
+  int reserved;
+  __global void* invoke;
+  struct Block_descriptor_1 {
+    unsigned long int reserved;         // NULL
+    unsigned long int size;         // sizeof(struct Block_literal_1)
+    // optional helper functions
+    void *copy_helper;                // IFF (1<<25)
+    void *dispose_helper;             // IFF (1<<25)
+    // required ABI.2010.3.16
+    const char *signature;                         // IFF (1<<30)
+  } *descriptor;
+  // imported variables
+};
+
+#if __clang_major__*10 + __clang_minor__ >= 50
+typedef struct ndrange_info_t ndrange_t;
+#endif
+
+#if __clang_major__*10 + __clang_minor__ >= 50
+#define BLOCK_TYPE void*
+#else
+#define BLOCK_TYPE __private void*
+#endif
+
+#if __clang_major__*10 + __clang_minor__ >= 40
+#define EVENT_TYPE clk_event_t*
+#else
+#define EVENT_TYPE __private clk_event_t*
+#endif
+
+clk_event_t create_user_event(void);
+void retain_event(clk_event_t event);
+void release_event(clk_event_t event);
+void set_user_event_status(clk_event_t event, int status);
+bool is_valid_event(clk_event_t event);
+void capture_event_profiling_info(clk_event_t event, int name, global void *value);
+
+uint __get_kernel_work_group_size_impl(BLOCK_TYPE block);
+uint __get_kernel_preferred_work_group_multiple_impl(BLOCK_TYPE block);
+
+int __enqueue_kernel_basic(queue_t q, int flag, ndrange_t ndrange, BLOCK_TYPE block);
+int __enqueue_kernel_basic_events(queue_t q, int flag, ndrange_t ndrange,
+                                  uint num_events_in_wait_list, const EVENT_TYPE event_wait_list,
+                                  EVENT_TYPE event_ret, BLOCK_TYPE block);
+
+queue_t get_default_queue(void);
+int __gen_enqueue_kernel_slm(queue_t q, int flag, ndrange_t ndrange, BLOCK_TYPE block, int count, __private int* slm_sizes);
+
+OVERLOADABLE ndrange_t ndrange_1D(size_t global_work_size);
+OVERLOADABLE ndrange_t ndrange_1D(size_t global_work_size, size_t local_work_size);
+OVERLOADABLE ndrange_t ndrange_1D(size_t global_work_offset, size_t global_work_size, size_t local_work_size);
+
+OVERLOADABLE ndrange_t ndrange_2D(const size_t global_work_size[2]);
+OVERLOADABLE ndrange_t ndrange_2D(const size_t global_work_size[2], const size_t local_work_size[2]);
+OVERLOADABLE ndrange_t ndrange_2D(const size_t global_work_offset[2], const size_t global_work_size[2], const size_t local_work_size[2]);
+
+OVERLOADABLE ndrange_t ndrange_3D(const size_t global_work_size[3]);
+OVERLOADABLE ndrange_t ndrange_3D(const size_t global_work_size[3], const size_t local_work_size[3]);
+OVERLOADABLE ndrange_t ndrange_3D(const size_t global_work_offset[3], const size_t global_work_size[3], const size_t local_work_size[3]);
+
+int enqueue_marker (queue_t queue, uint num_events_in_wait_list, const clk_event_t *event_wait_list, clk_event_t *event_ret);
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_float.h b/drivers/pocl-gen7/lib/beignet/include/ocl_float.h
new file mode 100644
index 0000000..77b78bb
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_float.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_FLOAT_H__
+#define __OCL_FLOAT_H__
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL floating-point macros and pragmas
+/////////////////////////////////////////////////////////////////////////////
+#define FLT_DIG 6
+#define FLT_MANT_DIG 24
+#define FLT_MAX_10_EXP +38
+#define FLT_MAX_EXP +128
+#define FLT_MIN_10_EXP -37
+#define FLT_MIN_EXP -125
+#define FLT_RADIX 2
+#define FLT_ONE 1.0000000000e+00         /* 0x3F800000 */
+#define FLT_MAX 0x1.fffffep127f
+#define FLT_MIN 0x1.0p-126f
+#define FLT_EPSILON 0x1.0p-23f
+
+#define MAXFLOAT     3.40282347e38F
+INLINE_OVERLOADABLE float __ocl_inff(void) {
+  union { uint u; float f; } u;
+  u.u = 0x7F800000;
+  return u.f;
+}
+INLINE_OVERLOADABLE float __ocl_nanf(void) {
+  union { uint u; float f; } u;
+  u.u = 0x7F800001;
+  return u.f;
+}
+typedef union
+{
+  float value;
+  uint  word;
+} float_shape_type;
+
+/* Get a 32 bit int from a float.  */
+#ifndef GEN_OCL_GET_FLOAT_WORD
+# define GEN_OCL_GET_FLOAT_WORD(i,d)  \
+do {                                  \
+  float_shape_type gf_u;              \
+  gf_u.value = (d);                   \
+  (i) = gf_u.word;                    \
+} while (0)
+#endif
+/* Set a float from a 32 bit int.  */
+#ifndef GEN_OCL_SET_FLOAT_WORD
+# define GEN_OCL_SET_FLOAT_WORD(d,i)  \
+do {                                  \
+  float_shape_type sf_u;              \
+  sf_u.word = (i);                    \
+  (d) = sf_u.value;                   \
+} while (0)
+#endif
+
+INLINE_OVERLOADABLE int __ocl_finitef (float x){
+  unsigned ix;
+  GEN_OCL_GET_FLOAT_WORD (ix, x);
+  return (ix & 0x7fffffff) < 0x7f800000;
+}
+
+#define HUGE_VALF    (__ocl_inff())
+#define INFINITY     (__ocl_inff())
+#define NAN          (__ocl_nanf())
+#define M_E_F        2.718281828459045F
+#define M_LOG2E_F    1.4426950408889634F
+#define M_LOG10E_F   0.43429448190325176F
+#define M_LOG210_F   3.3219280948873626F
+#define M_LN2_F      0.6931471805599453F
+#define M_LN10_F     2.302585092994046F
+#define M_PI_F       3.141592653589793F
+#define M_PI_2_F     1.5707963267948966F
+#define M_PI_4_F     0.7853981633974483F
+#define M_1_PI_F     0.3183098861837907F
+#define M_2_PI_F     0.6366197723675814F
+#define M_180_PI_F   57.295779513082321F
+#define M_2_SQRTPI_F 1.1283791670955126F
+#define M_SQRT2_F    1.4142135623730951F
+#define M_SQRT1_2_F  0.7071067811865476F
+#define FP_ILOGB0    (-0x7FFFFFFF-1)
+#define FP_ILOGBNAN  FP_ILOGB0
+
+#define DF_EXP_MASK 0x7FF0000000000000UL
+#define DF_MAX_NORMAL 0x7FF0000000000000UL
+#define DF_MAN_MASK 0xFFFFFFFFFFFFFUL
+#define DF_MIN_NORMAL 0x10000000000000UL
+#define DF_ABS_MASK 0x7FFFFFFFFFFFFFFFUL
+#define DF_POSITIVE_INF 0x7FF0000000000000UL
+#define DF_SIGN_MASK 0x8000000000000000UL
+#define DF_IMPLICITE_ONE 0x10000000000000UL
+#define DF_EXP_OFFSET 52
+#define DF_SIGN_OFFSET 63
+#define DF_EXP_BIAS 1023
+#define DF_NEGTIVE_INF 0xFFF0000000000000
+
+#define SF_POSITIVE_INF 0x7F800000
+#define SF_NAN 0x7FFFFFFF
+
+#define M_PI 3.141592653589793238462643383279
+
+#endif /* __OCL_FLOAT_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_geometric.h b/drivers/pocl-gen7/lib/beignet/include/ocl_geometric.h
new file mode 100644
index 0000000..6a312f8
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_geometric.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_GEOMETRIC_H__
+#define __OCL_GEOMETRIC_H__
+
+#include "ocl_types.h"
+
+OVERLOADABLE float dot(float p0, float p1);
+OVERLOADABLE float dot(float2 p0, float2 p1);
+OVERLOADABLE float dot(float3 p0, float3 p1);
+OVERLOADABLE float dot(float4 p0, float4 p1);
+OVERLOADABLE half dot(half p0, half p1);
+OVERLOADABLE half dot(half2 p0, half2 p1);
+OVERLOADABLE half dot(half3 p0, half3 p1);
+OVERLOADABLE half dot(half4 p0, half4 p1);
+OVERLOADABLE float length(float x);
+OVERLOADABLE float length(float2 x);
+OVERLOADABLE float length(float3 x);
+OVERLOADABLE float length(float4 x);
+OVERLOADABLE float distance(float x, float y);
+OVERLOADABLE float distance(float2 x, float2 y);
+OVERLOADABLE float distance(float3 x, float3 y);
+OVERLOADABLE float distance(float4 x, float4 y);
+OVERLOADABLE float normalize(float x);
+OVERLOADABLE float2 normalize(float2 x);
+OVERLOADABLE float3 normalize(float3 x);
+OVERLOADABLE float4 normalize(float4 x);
+
+OVERLOADABLE float fast_length(float x);
+OVERLOADABLE float fast_length(float2 x);
+OVERLOADABLE float fast_length(float3 x);
+OVERLOADABLE float fast_length(float4 x);
+OVERLOADABLE float fast_distance(float x, float y);
+OVERLOADABLE float fast_distance(float2 x, float2 y);
+OVERLOADABLE float fast_distance(float3 x, float3 y);
+OVERLOADABLE float fast_distance(float4 x, float4 y);
+OVERLOADABLE float fast_normalize(float x);
+OVERLOADABLE float2 fast_normalize(float2 x);
+OVERLOADABLE float3 fast_normalize(float3 x);
+OVERLOADABLE float4 fast_normalize(float4 x);
+
+OVERLOADABLE float3 cross(float3 v0, float3 v1);
+OVERLOADABLE float4 cross(float4 v0, float4 v1);
+
+OVERLOADABLE double dot(double p0, double p1);
+OVERLOADABLE double dot(double2 p0, double2 p1);
+OVERLOADABLE double dot(double3 p0, double3 p1);
+OVERLOADABLE double dot(double4 p0, double4 p1);
+OVERLOADABLE double length(double x);
+OVERLOADABLE double length(double2 x);
+OVERLOADABLE double length(double3 x);
+OVERLOADABLE double length(double4 x);
+OVERLOADABLE double distance(double x, double y);
+OVERLOADABLE double distance(double2 x, double2 y);
+OVERLOADABLE double distance(double3 x, double3 y);
+OVERLOADABLE double distance(double4 x, double4 y);
+OVERLOADABLE double normalize(double x);
+OVERLOADABLE double2 normalize(double2 x);
+OVERLOADABLE double3 normalize(double3 x);
+OVERLOADABLE double4 normalize(double4 x);
+OVERLOADABLE double3 cross(double3 v0, double3 v1);
+OVERLOADABLE double4 cross(double4 v0, double4 v1);
+
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_image.h b/drivers/pocl-gen7/lib/beignet/include/ocl_image.h
new file mode 100644
index 0000000..23c0690
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_image.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_IMAGE_H__
+#define __OCL_IMAGE_H__
+
+#include "ocl_types.h"
+
+#define int1 int
+#define float1 float
+
+#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
+
+#define DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, DATA_YPE, SUFFIX, N) \
+  OVERLOADABLE DATA_YPE read_image ## SUFFIX(IMG_TYPE cl_image, const sampler_t sampler, int##N coord); \
+  OVERLOADABLE DATA_YPE read_image ## SUFFIX(IMG_TYPE cl_image, const sampler_t sampler, float##N coord);
+
+#define DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, DATA_YPE, SUFFIX, N) \
+  OVERLOADABLE DATA_YPE read_image ## SUFFIX(IMG_TYPE cl_image, int##N coord);
+
+#define DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, DATA_YPE, SUFFIX, N) \
+  OVERLOADABLE void write_image ## SUFFIX(IMG_TYPE cl_image, int##N coord, DATA_YPE color);
+
+#define DECL_IMAGE_TYPE_READ_NO_SAMPLE(IMG_TYPE, N)\
+    DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, int4, i, N) \
+    DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, uint4, ui, N) \
+    DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, float4, f, N)
+
+#define DECL_IMAGE_TYPE_READ_SAMPLE(IMG_TYPE, N)\
+    DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, int4, i, N) \
+    DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, uint4, ui, N) \
+    DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, float4, f, N)
+
+#define DECL_IMAGE_TYPE_WRITE(IMG_TYPE, N)\
+    DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, int4, i, N) \
+    DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, uint4, ui, N) \
+    DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, float4, f, N)
+
+#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300)
+#define DECL_IMAGE(IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_write IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_SAMPLE(read_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_WRITE(read_write IMG_TYPE, N)
+#else
+#define DECL_IMAGE(IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_SAMPLE(read_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N)
+#endif
+
+DECL_IMAGE(image1d_t, 1)
+DECL_IMAGE(image2d_t, 2)
+DECL_IMAGE(image1d_array_t, 2)
+DECL_IMAGE(image3d_t, 3)
+DECL_IMAGE(image3d_t, 4)
+DECL_IMAGE(image2d_array_t, 3)
+DECL_IMAGE(image2d_array_t, 4)
+
+#undef DECL_IMAGE
+
+#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300)
+#define DECL_IMAGE(IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_write IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_WRITE(read_write IMG_TYPE, N)
+#else
+#define DECL_IMAGE(IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \
+    DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N)
+#endif
+
+DECL_IMAGE(image1d_buffer_t, 1)
+
+#undef int1
+#undef float1
+#undef DECL_IMAGE_TYPE_READ_NO_SAMPLE
+#undef DECL_IMAGE_TYPE_WRITE
+#undef DECL_IMAGE
+
+OVERLOADABLE int get_image_channel_data_type(read_only image1d_t image);
+OVERLOADABLE int get_image_channel_order(read_only image1d_t image);
+OVERLOADABLE int get_image_width(read_only image1d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_only image1d_buffer_t image);
+OVERLOADABLE int get_image_channel_order(read_only image1d_buffer_t image);
+OVERLOADABLE int get_image_width(read_only image1d_buffer_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_only image2d_t image);
+OVERLOADABLE int get_image_channel_order(read_only image2d_t image);
+OVERLOADABLE int get_image_width(read_only image2d_t image);
+OVERLOADABLE int get_image_height(read_only image2d_t image);
+OVERLOADABLE int2 get_image_dim(read_only image2d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_only image1d_array_t image);
+OVERLOADABLE int get_image_channel_order(read_only image1d_array_t image);
+OVERLOADABLE int get_image_width(read_only image1d_array_t image);
+OVERLOADABLE size_t get_image_array_size(read_only image1d_array_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_only image3d_t image);
+OVERLOADABLE int get_image_channel_order(read_only image3d_t image);
+OVERLOADABLE int get_image_width(read_only image3d_t image);
+OVERLOADABLE int get_image_height(read_only image3d_t image);
+OVERLOADABLE int get_image_depth(read_only image3d_t image);
+OVERLOADABLE int4 get_image_dim(read_only image3d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_only image2d_array_t image);
+OVERLOADABLE int get_image_channel_order(read_only image2d_array_t image);
+OVERLOADABLE int get_image_width(read_only image2d_array_t image);
+OVERLOADABLE int get_image_height(read_only image2d_array_t image);
+OVERLOADABLE int2 get_image_dim(read_only image2d_array_t image);
+OVERLOADABLE size_t get_image_array_size(read_only image2d_array_t image);
+
+#if __clang_major__*10 + __clang_minor__ >= 39
+OVERLOADABLE int get_image_channel_data_type(write_only image1d_t image);
+OVERLOADABLE int get_image_channel_order(write_only image1d_t image);
+OVERLOADABLE int get_image_width(write_only image1d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(write_only image1d_buffer_t image);
+OVERLOADABLE int get_image_channel_order(write_only image1d_buffer_t image);
+OVERLOADABLE int get_image_width(write_only image1d_buffer_t image);
+
+OVERLOADABLE int get_image_channel_data_type(write_only image2d_t image);
+OVERLOADABLE int get_image_channel_order(write_only image2d_t image);
+OVERLOADABLE int get_image_width(write_only image2d_t image);
+OVERLOADABLE int get_image_height(write_only image2d_t image);
+OVERLOADABLE int2 get_image_dim(write_only image2d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(write_only image1d_array_t image);
+OVERLOADABLE int get_image_channel_order(write_only image1d_array_t image);
+OVERLOADABLE int get_image_width(write_only image1d_array_t image);
+OVERLOADABLE size_t get_image_array_size(write_only image1d_array_t image);
+
+OVERLOADABLE int get_image_channel_data_type(write_only image3d_t image);
+OVERLOADABLE int get_image_channel_order(write_only image3d_t image);
+OVERLOADABLE int get_image_width(write_only image3d_t image);
+OVERLOADABLE int get_image_height(write_only image3d_t image);
+OVERLOADABLE int get_image_depth(write_only image3d_t image);
+OVERLOADABLE int4 get_image_dim(write_only image3d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(write_only image2d_array_t image);
+OVERLOADABLE int get_image_channel_order(write_only image2d_array_t image);
+OVERLOADABLE int get_image_width(write_only image2d_array_t image);
+OVERLOADABLE int get_image_height(write_only image2d_array_t image);
+OVERLOADABLE int2 get_image_dim(write_only image2d_array_t image);
+OVERLOADABLE size_t get_image_array_size(write_only image2d_array_t image);
+#endif
+
+#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300)
+OVERLOADABLE int get_image_channel_data_type(read_write image1d_t image);
+OVERLOADABLE int get_image_channel_order(read_write image1d_t image);
+OVERLOADABLE int get_image_width(read_write image1d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_write image1d_buffer_t image);
+OVERLOADABLE int get_image_channel_order(read_write image1d_buffer_t image);
+OVERLOADABLE int get_image_width(read_write image1d_buffer_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_write image2d_t image);
+OVERLOADABLE int get_image_channel_order(read_write image2d_t image);
+OVERLOADABLE int get_image_width(read_write image2d_t image);
+OVERLOADABLE int get_image_height(read_write image2d_t image);
+OVERLOADABLE int2 get_image_dim(read_write image2d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_write image1d_array_t image);
+OVERLOADABLE int get_image_channel_order(read_write image1d_array_t image);
+OVERLOADABLE int get_image_width(read_write image1d_array_t image);
+OVERLOADABLE size_t get_image_array_size(read_write image1d_array_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_write image3d_t image);
+OVERLOADABLE int get_image_channel_order(read_write image3d_t image);
+OVERLOADABLE int get_image_width(read_write image3d_t image);
+OVERLOADABLE int get_image_height(read_write image3d_t image);
+OVERLOADABLE int get_image_depth(read_write image3d_t image);
+OVERLOADABLE int4 get_image_dim(read_write image3d_t image);
+
+OVERLOADABLE int get_image_channel_data_type(read_write image2d_array_t image);
+OVERLOADABLE int get_image_channel_order(read_write image2d_array_t image);
+OVERLOADABLE int get_image_width(read_write image2d_array_t image);
+OVERLOADABLE int get_image_height(read_write image2d_array_t image);
+OVERLOADABLE int2 get_image_dim(read_write image2d_array_t image);
+OVERLOADABLE size_t get_image_array_size(read_write image2d_array_t image);
+#endif
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_integer.h b/drivers/pocl-gen7/lib/beignet/include/ocl_integer.h
new file mode 100644
index 0000000..60dec4b
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_integer.h
@@ -0,0 +1,1108 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_INTEGER_H__
+#define __OCL_INTEGER_H__
+
+#include "ocl_types.h"
+
+#define CHAR_BIT    8
+#define CHAR_MAX    SCHAR_MAX
+#define CHAR_MIN    SCHAR_MIN
+#define INT_MAX     2147483647
+#define INT_MIN     (-2147483647 - 1)
+#define LONG_MAX    0x7fffffffffffffffL
+#define LONG_MIN    (-0x7fffffffffffffffL - 1)
+#define SCHAR_MAX   127
+#define SCHAR_MIN   (-127 - 1)
+#define SHRT_MAX    32767
+#define SHRT_MIN    (-32767 - 1)
+#define UCHAR_MAX   255
+#define USHRT_MAX   65535
+#define UINT_MAX    0xffffffff
+#define ULONG_MAX   0xffffffffffffffffUL
+
+OVERLOADABLE char clz(char x);
+OVERLOADABLE uchar clz(uchar x);
+OVERLOADABLE short clz(short x);
+OVERLOADABLE ushort clz(ushort x);
+OVERLOADABLE int clz(int x);
+OVERLOADABLE uint clz(uint x);
+OVERLOADABLE long clz(long x);
+OVERLOADABLE ulong clz(ulong x);
+
+char   clz_s8(char);
+uchar  clz_u8(uchar);
+short  clz_s16(short);
+ushort clz_u16(ushort);
+int    clz_s32(int);
+uint   clz_u32(uint);
+long   clz_s64(long);
+ulong  clz_u64(ulong);
+
+OVERLOADABLE char ctz(char x);
+OVERLOADABLE uchar ctz(uchar x);
+OVERLOADABLE short ctz(short x);
+OVERLOADABLE ushort ctz(ushort x);
+OVERLOADABLE int ctz(int x);
+OVERLOADABLE uint ctz(uint x);
+OVERLOADABLE long ctz(long x);
+OVERLOADABLE ulong ctz(ulong x);
+
+char   ctz_s8(char);
+uchar  ctz_u8(uchar);
+short  ctz_s16(short);
+ushort ctz_u16(ushort);
+int    ctz_s32(int);
+uint   ctz_u32(uint);
+long   ctz_s64(long);
+ulong  ctz_u64(ulong);
+
+OVERLOADABLE char popcount(char x);
+OVERLOADABLE uchar popcount(uchar x);
+OVERLOADABLE short popcount(short x);
+OVERLOADABLE ushort popcount(ushort x);
+OVERLOADABLE int popcount(int x);
+OVERLOADABLE uint popcount(uint x);
+OVERLOADABLE long popcount(long x);
+OVERLOADABLE ulong popcount(ulong x);
+
+OVERLOADABLE char mul_hi(char x, char y);
+OVERLOADABLE uchar mul_hi(uchar x, uchar y);
+OVERLOADABLE short mul_hi(short x, short y);
+OVERLOADABLE ushort mul_hi(ushort x, ushort y);
+OVERLOADABLE int mul_hi(int x, int y);
+OVERLOADABLE uint mul_hi(uint x, uint y);
+OVERLOADABLE long mul_hi(long x, long y);
+OVERLOADABLE ulong mul_hi(ulong x, ulong y);
+
+#define SDEF(TYPE)        \
+OVERLOADABLE TYPE add_sat(TYPE x, TYPE y);   \
+OVERLOADABLE TYPE sub_sat(TYPE x, TYPE y);
+SDEF(char);
+SDEF(short);
+SDEF(int);
+SDEF(long);
+#undef SDEF
+#define UDEF(TYPE)  \
+OVERLOADABLE TYPE add_sat(TYPE x, TYPE y);   \
+OVERLOADABLE TYPE sub_sat(TYPE x, TYPE y);
+UDEF(uchar);
+UDEF(ushort);
+UDEF(uint);
+UDEF(ulong);
+#undef UDEF
+
+#define DEF(type) OVERLOADABLE type mad_hi(type a, type b, type c);
+DEF(char)
+DEF(uchar)
+DEF(short)
+DEF(ushort)
+DEF(int)
+DEF(uint)
+DEF(long)
+DEF(ulong)
+#undef DEF
+
+OVERLOADABLE int mul24(int a, int b);
+OVERLOADABLE uint mul24(uint a, uint b);
+
+OVERLOADABLE int mad24(int a, int b, int c);
+OVERLOADABLE uint mad24(uint a, uint b, uint c);
+
+OVERLOADABLE char mad_sat(char a, char b, char c) ;
+OVERLOADABLE uchar mad_sat(uchar a, uchar b, uchar c);
+OVERLOADABLE short mad_sat(short a, short b, short c);
+OVERLOADABLE ushort mad_sat(ushort a, ushort b, ushort c);
+OVERLOADABLE int mad_sat(int a, int b, int c);
+OVERLOADABLE uint mad_sat(uint a, uint b, uint c);
+OVERLOADABLE long mad_sat(long a, long b, long c);
+OVERLOADABLE ulong mad_sat(ulong a, ulong b, ulong c);
+
+#define DEF(type, m) OVERLOADABLE type rotate(type x, type y);
+DEF(char, 7)
+DEF(uchar, 7)
+DEF(short, 15)
+DEF(ushort, 15)
+DEF(int, 31)
+DEF(uint, 31)
+DEF(long, 63)
+DEF(ulong, 63)
+#undef DEF
+
+OVERLOADABLE short upsample(char hi, uchar lo);
+OVERLOADABLE ushort upsample(uchar hi, uchar lo);
+OVERLOADABLE int upsample(short hi, ushort lo);
+OVERLOADABLE uint upsample(ushort hi, ushort lo);
+OVERLOADABLE long upsample(int hi, uint lo);
+OVERLOADABLE ulong upsample(uint hi, uint lo);
+
+#define DEC DEF(char); DEF(uchar); DEF(short); DEF(ushort)
+#define DEF(type) OVERLOADABLE type hadd(type x, type y);
+DEC
+#undef DEF
+#define DEF(type) OVERLOADABLE type rhadd(type x, type y);
+DEC
+#undef DEF
+#undef DEC
+OVERLOADABLE int hadd(int x, int y);
+OVERLOADABLE uint hadd(uint x, uint y);
+OVERLOADABLE int rhadd(int x, int y);
+OVERLOADABLE uint rhadd(uint x, uint y);
+OVERLOADABLE long hadd(long x, long y);
+OVERLOADABLE ulong hadd(ulong x, ulong y);
+OVERLOADABLE long rhadd(long x, long y);
+OVERLOADABLE ulong rhadd(ulong x, ulong y);
+
+#define DEC(TYPE) OVERLOADABLE u##TYPE abs(TYPE x);
+DEC(int)
+DEC(short)
+DEC(char)
+#undef DEC
+OVERLOADABLE ulong abs(long x);
+/* For unsigned types, do nothing. */
+#define DEC(TYPE) OVERLOADABLE TYPE abs(TYPE x);
+DEC(uint)
+DEC(ushort)
+DEC(uchar)
+DEC(ulong)
+#undef DEC
+
+/* Char and short type abs diff */
+/* promote char and short to int and will be no module overflow */
+#define DEC(TYPE, UTYPE) OVERLOADABLE UTYPE abs_diff(TYPE x, TYPE y);
+DEC(char, uchar)
+DEC(uchar, uchar)
+DEC(short, ushort)
+DEC(ushort, ushort)
+#undef DEC
+
+OVERLOADABLE uint abs_diff (uint x, uint y);
+OVERLOADABLE uint abs_diff (int x, int y);
+OVERLOADABLE ulong abs_diff (long x, long y);
+OVERLOADABLE ulong abs_diff (ulong x, ulong y);
+
+
+#define DECL_MIN_MAX_CLAMP(TYPE) \
+OVERLOADABLE TYPE max(TYPE a, TYPE b);  \
+OVERLOADABLE TYPE min(TYPE a, TYPE b);  \
+OVERLOADABLE TYPE clamp(TYPE v, TYPE l, TYPE u);
+DECL_MIN_MAX_CLAMP(int)
+DECL_MIN_MAX_CLAMP(short)
+DECL_MIN_MAX_CLAMP(char)
+DECL_MIN_MAX_CLAMP(uint)
+DECL_MIN_MAX_CLAMP(unsigned short)
+DECL_MIN_MAX_CLAMP(unsigned char)
+DECL_MIN_MAX_CLAMP(long)
+DECL_MIN_MAX_CLAMP(ulong)
+#undef DECL_MIN_MAX_CLAMP
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//integer builtin functions
+//ugentype abs (gentype x)
+
+OVERLOADABLE uchar2 abs (char2 param0);
+OVERLOADABLE uchar3 abs (char3 param0);
+OVERLOADABLE uchar4 abs (char4 param0);
+OVERLOADABLE uchar8 abs (char8 param0);
+OVERLOADABLE uchar16 abs (char16 param0);
+OVERLOADABLE ushort2 abs (short2 param0);
+OVERLOADABLE ushort3 abs (short3 param0);
+OVERLOADABLE ushort4 abs (short4 param0);
+OVERLOADABLE ushort8 abs (short8 param0);
+OVERLOADABLE ushort16 abs (short16 param0);
+OVERLOADABLE uint2 abs (int2 param0);
+OVERLOADABLE uint3 abs (int3 param0);
+OVERLOADABLE uint4 abs (int4 param0);
+OVERLOADABLE uint8 abs (int8 param0);
+OVERLOADABLE uint16 abs (int16 param0);
+OVERLOADABLE ulong2 abs (long2 param0);
+OVERLOADABLE ulong3 abs (long3 param0);
+OVERLOADABLE ulong4 abs (long4 param0);
+OVERLOADABLE ulong8 abs (long8 param0);
+OVERLOADABLE ulong16 abs (long16 param0);
+OVERLOADABLE uchar2 abs (uchar2 param0);
+OVERLOADABLE uchar3 abs (uchar3 param0);
+OVERLOADABLE uchar4 abs (uchar4 param0);
+OVERLOADABLE uchar8 abs (uchar8 param0);
+OVERLOADABLE uchar16 abs (uchar16 param0);
+OVERLOADABLE ushort2 abs (ushort2 param0);
+OVERLOADABLE ushort3 abs (ushort3 param0);
+OVERLOADABLE ushort4 abs (ushort4 param0);
+OVERLOADABLE ushort8 abs (ushort8 param0);
+OVERLOADABLE ushort16 abs (ushort16 param0);
+OVERLOADABLE uint2 abs (uint2 param0);
+OVERLOADABLE uint3 abs (uint3 param0);
+OVERLOADABLE uint4 abs (uint4 param0);
+OVERLOADABLE uint8 abs (uint8 param0);
+OVERLOADABLE uint16 abs (uint16 param0);
+OVERLOADABLE ulong2 abs (ulong2 param0);
+OVERLOADABLE ulong3 abs (ulong3 param0);
+OVERLOADABLE ulong4 abs (ulong4 param0);
+OVERLOADABLE ulong8 abs (ulong8 param0);
+OVERLOADABLE ulong16 abs (ulong16 param0);
+
+//ugentype abs_diff (gentype x, gentype y)
+
+OVERLOADABLE uchar2 abs_diff (char2 param0, char2 param1);
+OVERLOADABLE uchar3 abs_diff (char3 param0, char3 param1);
+OVERLOADABLE uchar4 abs_diff (char4 param0, char4 param1);
+OVERLOADABLE uchar8 abs_diff (char8 param0, char8 param1);
+OVERLOADABLE uchar16 abs_diff (char16 param0, char16 param1);
+OVERLOADABLE ushort2 abs_diff (short2 param0, short2 param1);
+OVERLOADABLE ushort3 abs_diff (short3 param0, short3 param1);
+OVERLOADABLE ushort4 abs_diff (short4 param0, short4 param1);
+OVERLOADABLE ushort8 abs_diff (short8 param0, short8 param1);
+OVERLOADABLE ushort16 abs_diff (short16 param0, short16 param1);
+OVERLOADABLE uint2 abs_diff (int2 param0, int2 param1);
+OVERLOADABLE uint3 abs_diff (int3 param0, int3 param1);
+OVERLOADABLE uint4 abs_diff (int4 param0, int4 param1);
+OVERLOADABLE uint8 abs_diff (int8 param0, int8 param1);
+OVERLOADABLE uint16 abs_diff (int16 param0, int16 param1);
+OVERLOADABLE ulong2 abs_diff (long2 param0, long2 param1);
+OVERLOADABLE ulong3 abs_diff (long3 param0, long3 param1);
+OVERLOADABLE ulong4 abs_diff (long4 param0, long4 param1);
+OVERLOADABLE ulong8 abs_diff (long8 param0, long8 param1);
+OVERLOADABLE ulong16 abs_diff (long16 param0, long16 param1);
+OVERLOADABLE uchar2 abs_diff (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 abs_diff (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 abs_diff (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 abs_diff (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 abs_diff (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 abs_diff (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 abs_diff (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 abs_diff (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 abs_diff (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 abs_diff (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 abs_diff (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 abs_diff (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 abs_diff (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 abs_diff (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 abs_diff (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 abs_diff (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 abs_diff (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 abs_diff (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 abs_diff (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 abs_diff (ulong16 param0, ulong16 param1);
+
+//gentype add_sat (gentype x,  gentype y)
+
+OVERLOADABLE char2 add_sat (char2 param0, char2 param1);
+OVERLOADABLE char3 add_sat (char3 param0, char3 param1);
+OVERLOADABLE char4 add_sat (char4 param0, char4 param1);
+OVERLOADABLE char8 add_sat (char8 param0, char8 param1);
+OVERLOADABLE char16 add_sat (char16 param0, char16 param1);
+OVERLOADABLE short2 add_sat (short2 param0, short2 param1);
+OVERLOADABLE short3 add_sat (short3 param0, short3 param1);
+OVERLOADABLE short4 add_sat (short4 param0, short4 param1);
+OVERLOADABLE short8 add_sat (short8 param0, short8 param1);
+OVERLOADABLE short16 add_sat (short16 param0, short16 param1);
+OVERLOADABLE int2 add_sat (int2 param0, int2 param1);
+OVERLOADABLE int3 add_sat (int3 param0, int3 param1);
+OVERLOADABLE int4 add_sat (int4 param0, int4 param1);
+OVERLOADABLE int8 add_sat (int8 param0, int8 param1);
+OVERLOADABLE int16 add_sat (int16 param0, int16 param1);
+OVERLOADABLE long2 add_sat (long2 param0, long2 param1);
+OVERLOADABLE long3 add_sat (long3 param0, long3 param1);
+OVERLOADABLE long4 add_sat (long4 param0, long4 param1);
+OVERLOADABLE long8 add_sat (long8 param0, long8 param1);
+OVERLOADABLE long16 add_sat (long16 param0, long16 param1);
+OVERLOADABLE uchar2 add_sat (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 add_sat (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 add_sat (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 add_sat (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 add_sat (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 add_sat (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 add_sat (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 add_sat (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 add_sat (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 add_sat (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 add_sat (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 add_sat (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 add_sat (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 add_sat (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 add_sat (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 add_sat (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 add_sat (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 add_sat (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 add_sat (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 add_sat (ulong16 param0, ulong16 param1);
+
+//gentype hadd (gentype x,  gentype y)
+
+OVERLOADABLE char2 hadd (char2 param0, char2 param1);
+OVERLOADABLE char3 hadd (char3 param0, char3 param1);
+OVERLOADABLE char4 hadd (char4 param0, char4 param1);
+OVERLOADABLE char8 hadd (char8 param0, char8 param1);
+OVERLOADABLE char16 hadd (char16 param0, char16 param1);
+OVERLOADABLE short2 hadd (short2 param0, short2 param1);
+OVERLOADABLE short3 hadd (short3 param0, short3 param1);
+OVERLOADABLE short4 hadd (short4 param0, short4 param1);
+OVERLOADABLE short8 hadd (short8 param0, short8 param1);
+OVERLOADABLE short16 hadd (short16 param0, short16 param1);
+OVERLOADABLE int2 hadd (int2 param0, int2 param1);
+OVERLOADABLE int3 hadd (int3 param0, int3 param1);
+OVERLOADABLE int4 hadd (int4 param0, int4 param1);
+OVERLOADABLE int8 hadd (int8 param0, int8 param1);
+OVERLOADABLE int16 hadd (int16 param0, int16 param1);
+OVERLOADABLE long2 hadd (long2 param0, long2 param1);
+OVERLOADABLE long3 hadd (long3 param0, long3 param1);
+OVERLOADABLE long4 hadd (long4 param0, long4 param1);
+OVERLOADABLE long8 hadd (long8 param0, long8 param1);
+OVERLOADABLE long16 hadd (long16 param0, long16 param1);
+OVERLOADABLE uchar2 hadd (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 hadd (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 hadd (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 hadd (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 hadd (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 hadd (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 hadd (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 hadd (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 hadd (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 hadd (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 hadd (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 hadd (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 hadd (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 hadd (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 hadd (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 hadd (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 hadd (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 hadd (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 hadd (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 hadd (ulong16 param0, ulong16 param1);
+
+//gentype rhadd (gentype x, gentype y)
+
+OVERLOADABLE char2 rhadd (char2 param0, char2 param1);
+OVERLOADABLE char3 rhadd (char3 param0, char3 param1);
+OVERLOADABLE char4 rhadd (char4 param0, char4 param1);
+OVERLOADABLE char8 rhadd (char8 param0, char8 param1);
+OVERLOADABLE char16 rhadd (char16 param0, char16 param1);
+OVERLOADABLE short2 rhadd (short2 param0, short2 param1);
+OVERLOADABLE short3 rhadd (short3 param0, short3 param1);
+OVERLOADABLE short4 rhadd (short4 param0, short4 param1);
+OVERLOADABLE short8 rhadd (short8 param0, short8 param1);
+OVERLOADABLE short16 rhadd (short16 param0, short16 param1);
+OVERLOADABLE int2 rhadd (int2 param0, int2 param1);
+OVERLOADABLE int3 rhadd (int3 param0, int3 param1);
+OVERLOADABLE int4 rhadd (int4 param0, int4 param1);
+OVERLOADABLE int8 rhadd (int8 param0, int8 param1);
+OVERLOADABLE int16 rhadd (int16 param0, int16 param1);
+OVERLOADABLE long2 rhadd (long2 param0, long2 param1);
+OVERLOADABLE long3 rhadd (long3 param0, long3 param1);
+OVERLOADABLE long4 rhadd (long4 param0, long4 param1);
+OVERLOADABLE long8 rhadd (long8 param0, long8 param1);
+OVERLOADABLE long16 rhadd (long16 param0, long16 param1);
+OVERLOADABLE uchar2 rhadd (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 rhadd (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 rhadd (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 rhadd (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 rhadd (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 rhadd (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 rhadd (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 rhadd (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 rhadd (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 rhadd (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 rhadd (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 rhadd (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 rhadd (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 rhadd (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 rhadd (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 rhadd (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 rhadd (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 rhadd (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 rhadd (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 rhadd (ulong16 param0, ulong16 param1);
+
+//gentype clamp (gentype x, gentype minval, gentype maxval)
+
+OVERLOADABLE char2 clamp (char2 param0, char2 param1, char2 param2);
+OVERLOADABLE char3 clamp (char3 param0, char3 param1, char3 param2);
+OVERLOADABLE char4 clamp (char4 param0, char4 param1, char4 param2);
+OVERLOADABLE char8 clamp (char8 param0, char8 param1, char8 param2);
+OVERLOADABLE char16 clamp (char16 param0, char16 param1, char16 param2);
+OVERLOADABLE short2 clamp (short2 param0, short2 param1, short2 param2);
+OVERLOADABLE short3 clamp (short3 param0, short3 param1, short3 param2);
+OVERLOADABLE short4 clamp (short4 param0, short4 param1, short4 param2);
+OVERLOADABLE short8 clamp (short8 param0, short8 param1, short8 param2);
+OVERLOADABLE short16 clamp (short16 param0, short16 param1, short16 param2);
+OVERLOADABLE int2 clamp (int2 param0, int2 param1, int2 param2);
+OVERLOADABLE int3 clamp (int3 param0, int3 param1, int3 param2);
+OVERLOADABLE int4 clamp (int4 param0, int4 param1, int4 param2);
+OVERLOADABLE int8 clamp (int8 param0, int8 param1, int8 param2);
+OVERLOADABLE int16 clamp (int16 param0, int16 param1, int16 param2);
+OVERLOADABLE long2 clamp (long2 param0, long2 param1, long2 param2);
+OVERLOADABLE long3 clamp (long3 param0, long3 param1, long3 param2);
+OVERLOADABLE long4 clamp (long4 param0, long4 param1, long4 param2);
+OVERLOADABLE long8 clamp (long8 param0, long8 param1, long8 param2);
+OVERLOADABLE long16 clamp (long16 param0, long16 param1, long16 param2);
+OVERLOADABLE uchar2 clamp (uchar2 param0, uchar2 param1, uchar2 param2);
+OVERLOADABLE uchar3 clamp (uchar3 param0, uchar3 param1, uchar3 param2);
+OVERLOADABLE uchar4 clamp (uchar4 param0, uchar4 param1, uchar4 param2);
+OVERLOADABLE uchar8 clamp (uchar8 param0, uchar8 param1, uchar8 param2);
+OVERLOADABLE uchar16 clamp (uchar16 param0, uchar16 param1, uchar16 param2);
+OVERLOADABLE ushort2 clamp (ushort2 param0, ushort2 param1, ushort2 param2);
+OVERLOADABLE ushort3 clamp (ushort3 param0, ushort3 param1, ushort3 param2);
+OVERLOADABLE ushort4 clamp (ushort4 param0, ushort4 param1, ushort4 param2);
+OVERLOADABLE ushort8 clamp (ushort8 param0, ushort8 param1, ushort8 param2);
+OVERLOADABLE ushort16 clamp (ushort16 param0, ushort16 param1, ushort16 param2);
+OVERLOADABLE uint2 clamp (uint2 param0, uint2 param1, uint2 param2);
+OVERLOADABLE uint3 clamp (uint3 param0, uint3 param1, uint3 param2);
+OVERLOADABLE uint4 clamp (uint4 param0, uint4 param1, uint4 param2);
+OVERLOADABLE uint8 clamp (uint8 param0, uint8 param1, uint8 param2);
+OVERLOADABLE uint16 clamp (uint16 param0, uint16 param1, uint16 param2);
+OVERLOADABLE ulong2 clamp (ulong2 param0, ulong2 param1, ulong2 param2);
+OVERLOADABLE ulong3 clamp (ulong3 param0, ulong3 param1, ulong3 param2);
+OVERLOADABLE ulong4 clamp (ulong4 param0, ulong4 param1, ulong4 param2);
+OVERLOADABLE ulong8 clamp (ulong8 param0, ulong8 param1, ulong8 param2);
+OVERLOADABLE ulong16 clamp (ulong16 param0, ulong16 param1, ulong16 param2);
+
+//gentype clamp (gentype x, sgentype minval, sgentype maxval)
+
+OVERLOADABLE char2 clamp (char2 param0, char param1, char param2);
+OVERLOADABLE char3 clamp (char3 param0, char param1, char param2);
+OVERLOADABLE char4 clamp (char4 param0, char param1, char param2);
+OVERLOADABLE char8 clamp (char8 param0, char param1, char param2);
+OVERLOADABLE char16 clamp (char16 param0, char param1, char param2);
+OVERLOADABLE short2 clamp (short2 param0, short param1, short param2);
+OVERLOADABLE short3 clamp (short3 param0, short param1, short param2);
+OVERLOADABLE short4 clamp (short4 param0, short param1, short param2);
+OVERLOADABLE short8 clamp (short8 param0, short param1, short param2);
+OVERLOADABLE short16 clamp (short16 param0, short param1, short param2);
+OVERLOADABLE int2 clamp (int2 param0, int param1, int param2);
+OVERLOADABLE int3 clamp (int3 param0, int param1, int param2);
+OVERLOADABLE int4 clamp (int4 param0, int param1, int param2);
+OVERLOADABLE int8 clamp (int8 param0, int param1, int param2);
+OVERLOADABLE int16 clamp (int16 param0, int param1, int param2);
+OVERLOADABLE long2 clamp (long2 param0, long param1, long param2);
+OVERLOADABLE long3 clamp (long3 param0, long param1, long param2);
+OVERLOADABLE long4 clamp (long4 param0, long param1, long param2);
+OVERLOADABLE long8 clamp (long8 param0, long param1, long param2);
+OVERLOADABLE long16 clamp (long16 param0, long param1, long param2);
+OVERLOADABLE uchar2 clamp (uchar2 param0, uchar param1, uchar param2);
+OVERLOADABLE uchar3 clamp (uchar3 param0, uchar param1, uchar param2);
+OVERLOADABLE uchar4 clamp (uchar4 param0, uchar param1, uchar param2);
+OVERLOADABLE uchar8 clamp (uchar8 param0, uchar param1, uchar param2);
+OVERLOADABLE uchar16 clamp (uchar16 param0, uchar param1, uchar param2);
+OVERLOADABLE ushort2 clamp (ushort2 param0, ushort param1, ushort param2);
+OVERLOADABLE ushort3 clamp (ushort3 param0, ushort param1, ushort param2);
+OVERLOADABLE ushort4 clamp (ushort4 param0, ushort param1, ushort param2);
+OVERLOADABLE ushort8 clamp (ushort8 param0, ushort param1, ushort param2);
+OVERLOADABLE ushort16 clamp (ushort16 param0, ushort param1, ushort param2);
+OVERLOADABLE uint2 clamp (uint2 param0, uint param1, uint param2);
+OVERLOADABLE uint3 clamp (uint3 param0, uint param1, uint param2);
+OVERLOADABLE uint4 clamp (uint4 param0, uint param1, uint param2);
+OVERLOADABLE uint8 clamp (uint8 param0, uint param1, uint param2);
+OVERLOADABLE uint16 clamp (uint16 param0, uint param1, uint param2);
+OVERLOADABLE ulong2 clamp (ulong2 param0, ulong param1, ulong param2);
+OVERLOADABLE ulong3 clamp (ulong3 param0, ulong param1, ulong param2);
+OVERLOADABLE ulong4 clamp (ulong4 param0, ulong param1, ulong param2);
+OVERLOADABLE ulong8 clamp (ulong8 param0, ulong param1, ulong param2);
+OVERLOADABLE ulong16 clamp (ulong16 param0, ulong param1, ulong param2);
+
+//gentype clz (gentype x)
+
+OVERLOADABLE char2 clz (char2 param0);
+OVERLOADABLE char3 clz (char3 param0);
+OVERLOADABLE char4 clz (char4 param0);
+OVERLOADABLE char8 clz (char8 param0);
+OVERLOADABLE char16 clz (char16 param0);
+OVERLOADABLE short2 clz (short2 param0);
+OVERLOADABLE short3 clz (short3 param0);
+OVERLOADABLE short4 clz (short4 param0);
+OVERLOADABLE short8 clz (short8 param0);
+OVERLOADABLE short16 clz (short16 param0);
+OVERLOADABLE int2 clz (int2 param0);
+OVERLOADABLE int3 clz (int3 param0);
+OVERLOADABLE int4 clz (int4 param0);
+OVERLOADABLE int8 clz (int8 param0);
+OVERLOADABLE int16 clz (int16 param0);
+OVERLOADABLE long2 clz (long2 param0);
+OVERLOADABLE long3 clz (long3 param0);
+OVERLOADABLE long4 clz (long4 param0);
+OVERLOADABLE long8 clz (long8 param0);
+OVERLOADABLE long16 clz (long16 param0);
+OVERLOADABLE uchar2 clz (uchar2 param0);
+OVERLOADABLE uchar3 clz (uchar3 param0);
+OVERLOADABLE uchar4 clz (uchar4 param0);
+OVERLOADABLE uchar8 clz (uchar8 param0);
+OVERLOADABLE uchar16 clz (uchar16 param0);
+OVERLOADABLE ushort2 clz (ushort2 param0);
+OVERLOADABLE ushort3 clz (ushort3 param0);
+OVERLOADABLE ushort4 clz (ushort4 param0);
+OVERLOADABLE ushort8 clz (ushort8 param0);
+OVERLOADABLE ushort16 clz (ushort16 param0);
+OVERLOADABLE uint2 clz (uint2 param0);
+OVERLOADABLE uint3 clz (uint3 param0);
+OVERLOADABLE uint4 clz (uint4 param0);
+OVERLOADABLE uint8 clz (uint8 param0);
+OVERLOADABLE uint16 clz (uint16 param0);
+OVERLOADABLE ulong2 clz (ulong2 param0);
+OVERLOADABLE ulong3 clz (ulong3 param0);
+OVERLOADABLE ulong4 clz (ulong4 param0);
+OVERLOADABLE ulong8 clz (ulong8 param0);
+OVERLOADABLE ulong16 clz (ulong16 param0);
+
+//gentype ctz (gentype x)
+
+OVERLOADABLE char2 ctz (char2 param0);
+OVERLOADABLE char3 ctz (char3 param0);
+OVERLOADABLE char4 ctz (char4 param0);
+OVERLOADABLE char8 ctz (char8 param0);
+OVERLOADABLE char16 ctz (char16 param0);
+OVERLOADABLE short2 ctz (short2 param0);
+OVERLOADABLE short3 ctz (short3 param0);
+OVERLOADABLE short4 ctz (short4 param0);
+OVERLOADABLE short8 ctz (short8 param0);
+OVERLOADABLE short16 ctz (short16 param0);
+OVERLOADABLE int2 ctz (int2 param0);
+OVERLOADABLE int3 ctz (int3 param0);
+OVERLOADABLE int4 ctz (int4 param0);
+OVERLOADABLE int8 ctz (int8 param0);
+OVERLOADABLE int16 ctz (int16 param0);
+OVERLOADABLE long2 ctz (long2 param0);
+OVERLOADABLE long3 ctz (long3 param0);
+OVERLOADABLE long4 ctz (long4 param0);
+OVERLOADABLE long8 ctz (long8 param0);
+OVERLOADABLE long16 ctz (long16 param0);
+OVERLOADABLE uchar2 ctz (uchar2 param0);
+OVERLOADABLE uchar3 ctz (uchar3 param0);
+OVERLOADABLE uchar4 ctz (uchar4 param0);
+OVERLOADABLE uchar8 ctz (uchar8 param0);
+OVERLOADABLE uchar16 ctz (uchar16 param0);
+OVERLOADABLE ushort2 ctz (ushort2 param0);
+OVERLOADABLE ushort3 ctz (ushort3 param0);
+OVERLOADABLE ushort4 ctz (ushort4 param0);
+OVERLOADABLE ushort8 ctz (ushort8 param0);
+OVERLOADABLE ushort16 ctz (ushort16 param0);
+OVERLOADABLE uint2 ctz (uint2 param0);
+OVERLOADABLE uint3 ctz (uint3 param0);
+OVERLOADABLE uint4 ctz (uint4 param0);
+OVERLOADABLE uint8 ctz (uint8 param0);
+OVERLOADABLE uint16 ctz (uint16 param0);
+OVERLOADABLE ulong2 ctz (ulong2 param0);
+OVERLOADABLE ulong3 ctz (ulong3 param0);
+OVERLOADABLE ulong4 ctz (ulong4 param0);
+OVERLOADABLE ulong8 ctz (ulong8 param0);
+OVERLOADABLE ulong16 ctz (ulong16 param0);
+
+//gentype mad_hi (gentype a, gentype b, gentype c)
+
+OVERLOADABLE char2 mad_hi (char2 param0, char2 param1, char2 param2);
+OVERLOADABLE char3 mad_hi (char3 param0, char3 param1, char3 param2);
+OVERLOADABLE char4 mad_hi (char4 param0, char4 param1, char4 param2);
+OVERLOADABLE char8 mad_hi (char8 param0, char8 param1, char8 param2);
+OVERLOADABLE char16 mad_hi (char16 param0, char16 param1, char16 param2);
+OVERLOADABLE short2 mad_hi (short2 param0, short2 param1, short2 param2);
+OVERLOADABLE short3 mad_hi (short3 param0, short3 param1, short3 param2);
+OVERLOADABLE short4 mad_hi (short4 param0, short4 param1, short4 param2);
+OVERLOADABLE short8 mad_hi (short8 param0, short8 param1, short8 param2);
+OVERLOADABLE short16 mad_hi (short16 param0, short16 param1, short16 param2);
+OVERLOADABLE int2 mad_hi (int2 param0, int2 param1, int2 param2);
+OVERLOADABLE int3 mad_hi (int3 param0, int3 param1, int3 param2);
+OVERLOADABLE int4 mad_hi (int4 param0, int4 param1, int4 param2);
+OVERLOADABLE int8 mad_hi (int8 param0, int8 param1, int8 param2);
+OVERLOADABLE int16 mad_hi (int16 param0, int16 param1, int16 param2);
+OVERLOADABLE long2 mad_hi (long2 param0, long2 param1, long2 param2);
+OVERLOADABLE long3 mad_hi (long3 param0, long3 param1, long3 param2);
+OVERLOADABLE long4 mad_hi (long4 param0, long4 param1, long4 param2);
+OVERLOADABLE long8 mad_hi (long8 param0, long8 param1, long8 param2);
+OVERLOADABLE long16 mad_hi (long16 param0, long16 param1, long16 param2);
+OVERLOADABLE uchar2 mad_hi (uchar2 param0, uchar2 param1, uchar2 param2);
+OVERLOADABLE uchar3 mad_hi (uchar3 param0, uchar3 param1, uchar3 param2);
+OVERLOADABLE uchar4 mad_hi (uchar4 param0, uchar4 param1, uchar4 param2);
+OVERLOADABLE uchar8 mad_hi (uchar8 param0, uchar8 param1, uchar8 param2);
+OVERLOADABLE uchar16 mad_hi (uchar16 param0, uchar16 param1, uchar16 param2);
+OVERLOADABLE ushort2 mad_hi (ushort2 param0, ushort2 param1, ushort2 param2);
+OVERLOADABLE ushort3 mad_hi (ushort3 param0, ushort3 param1, ushort3 param2);
+OVERLOADABLE ushort4 mad_hi (ushort4 param0, ushort4 param1, ushort4 param2);
+OVERLOADABLE ushort8 mad_hi (ushort8 param0, ushort8 param1, ushort8 param2);
+OVERLOADABLE ushort16 mad_hi (ushort16 param0, ushort16 param1, ushort16 param2);
+OVERLOADABLE uint2 mad_hi (uint2 param0, uint2 param1, uint2 param2);
+OVERLOADABLE uint3 mad_hi (uint3 param0, uint3 param1, uint3 param2);
+OVERLOADABLE uint4 mad_hi (uint4 param0, uint4 param1, uint4 param2);
+OVERLOADABLE uint8 mad_hi (uint8 param0, uint8 param1, uint8 param2);
+OVERLOADABLE uint16 mad_hi (uint16 param0, uint16 param1, uint16 param2);
+OVERLOADABLE ulong2 mad_hi (ulong2 param0, ulong2 param1, ulong2 param2);
+OVERLOADABLE ulong3 mad_hi (ulong3 param0, ulong3 param1, ulong3 param2);
+OVERLOADABLE ulong4 mad_hi (ulong4 param0, ulong4 param1, ulong4 param2);
+OVERLOADABLE ulong8 mad_hi (ulong8 param0, ulong8 param1, ulong8 param2);
+OVERLOADABLE ulong16 mad_hi (ulong16 param0, ulong16 param1, ulong16 param2);
+
+//gentype mad_sat (gentype a, gentype b, gentype c)
+
+OVERLOADABLE char2 mad_sat (char2 param0, char2 param1, char2 param2);
+OVERLOADABLE char3 mad_sat (char3 param0, char3 param1, char3 param2);
+OVERLOADABLE char4 mad_sat (char4 param0, char4 param1, char4 param2);
+OVERLOADABLE char8 mad_sat (char8 param0, char8 param1, char8 param2);
+OVERLOADABLE char16 mad_sat (char16 param0, char16 param1, char16 param2);
+OVERLOADABLE short2 mad_sat (short2 param0, short2 param1, short2 param2);
+OVERLOADABLE short3 mad_sat (short3 param0, short3 param1, short3 param2);
+OVERLOADABLE short4 mad_sat (short4 param0, short4 param1, short4 param2);
+OVERLOADABLE short8 mad_sat (short8 param0, short8 param1, short8 param2);
+OVERLOADABLE short16 mad_sat (short16 param0, short16 param1, short16 param2);
+OVERLOADABLE int2 mad_sat (int2 param0, int2 param1, int2 param2);
+OVERLOADABLE int3 mad_sat (int3 param0, int3 param1, int3 param2);
+OVERLOADABLE int4 mad_sat (int4 param0, int4 param1, int4 param2);
+OVERLOADABLE int8 mad_sat (int8 param0, int8 param1, int8 param2);
+OVERLOADABLE int16 mad_sat (int16 param0, int16 param1, int16 param2);
+OVERLOADABLE long2 mad_sat (long2 param0, long2 param1, long2 param2);
+OVERLOADABLE long3 mad_sat (long3 param0, long3 param1, long3 param2);
+OVERLOADABLE long4 mad_sat (long4 param0, long4 param1, long4 param2);
+OVERLOADABLE long8 mad_sat (long8 param0, long8 param1, long8 param2);
+OVERLOADABLE long16 mad_sat (long16 param0, long16 param1, long16 param2);
+OVERLOADABLE uchar2 mad_sat (uchar2 param0, uchar2 param1, uchar2 param2);
+OVERLOADABLE uchar3 mad_sat (uchar3 param0, uchar3 param1, uchar3 param2);
+OVERLOADABLE uchar4 mad_sat (uchar4 param0, uchar4 param1, uchar4 param2);
+OVERLOADABLE uchar8 mad_sat (uchar8 param0, uchar8 param1, uchar8 param2);
+OVERLOADABLE uchar16 mad_sat (uchar16 param0, uchar16 param1, uchar16 param2);
+OVERLOADABLE ushort2 mad_sat (ushort2 param0, ushort2 param1, ushort2 param2);
+OVERLOADABLE ushort3 mad_sat (ushort3 param0, ushort3 param1, ushort3 param2);
+OVERLOADABLE ushort4 mad_sat (ushort4 param0, ushort4 param1, ushort4 param2);
+OVERLOADABLE ushort8 mad_sat (ushort8 param0, ushort8 param1, ushort8 param2);
+OVERLOADABLE ushort16 mad_sat (ushort16 param0, ushort16 param1, ushort16 param2);
+OVERLOADABLE uint2 mad_sat (uint2 param0, uint2 param1, uint2 param2);
+OVERLOADABLE uint3 mad_sat (uint3 param0, uint3 param1, uint3 param2);
+OVERLOADABLE uint4 mad_sat (uint4 param0, uint4 param1, uint4 param2);
+OVERLOADABLE uint8 mad_sat (uint8 param0, uint8 param1, uint8 param2);
+OVERLOADABLE uint16 mad_sat (uint16 param0, uint16 param1, uint16 param2);
+OVERLOADABLE ulong2 mad_sat (ulong2 param0, ulong2 param1, ulong2 param2);
+OVERLOADABLE ulong3 mad_sat (ulong3 param0, ulong3 param1, ulong3 param2);
+OVERLOADABLE ulong4 mad_sat (ulong4 param0, ulong4 param1, ulong4 param2);
+OVERLOADABLE ulong8 mad_sat (ulong8 param0, ulong8 param1, ulong8 param2);
+OVERLOADABLE ulong16 mad_sat (ulong16 param0, ulong16 param1, ulong16 param2);
+
+//gentype max (gentype x,  gentype y)
+
+OVERLOADABLE char2 max (char2 param0, char2 param1);
+OVERLOADABLE char3 max (char3 param0, char3 param1);
+OVERLOADABLE char4 max (char4 param0, char4 param1);
+OVERLOADABLE char8 max (char8 param0, char8 param1);
+OVERLOADABLE char16 max (char16 param0, char16 param1);
+OVERLOADABLE short2 max (short2 param0, short2 param1);
+OVERLOADABLE short3 max (short3 param0, short3 param1);
+OVERLOADABLE short4 max (short4 param0, short4 param1);
+OVERLOADABLE short8 max (short8 param0, short8 param1);
+OVERLOADABLE short16 max (short16 param0, short16 param1);
+OVERLOADABLE int2 max (int2 param0, int2 param1);
+OVERLOADABLE int3 max (int3 param0, int3 param1);
+OVERLOADABLE int4 max (int4 param0, int4 param1);
+OVERLOADABLE int8 max (int8 param0, int8 param1);
+OVERLOADABLE int16 max (int16 param0, int16 param1);
+OVERLOADABLE long2 max (long2 param0, long2 param1);
+OVERLOADABLE long3 max (long3 param0, long3 param1);
+OVERLOADABLE long4 max (long4 param0, long4 param1);
+OVERLOADABLE long8 max (long8 param0, long8 param1);
+OVERLOADABLE long16 max (long16 param0, long16 param1);
+OVERLOADABLE uchar2 max (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 max (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 max (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 max (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 max (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 max (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 max (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 max (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 max (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 max (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 max (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 max (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 max (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 max (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 max (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 max (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 max (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 max (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 max (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 max (ulong16 param0, ulong16 param1);
+
+//gentype max (gentype x,  sgentype y)
+
+OVERLOADABLE char2 max (char2 param0, char param1);
+OVERLOADABLE char3 max (char3 param0, char param1);
+OVERLOADABLE char4 max (char4 param0, char param1);
+OVERLOADABLE char8 max (char8 param0, char param1);
+OVERLOADABLE char16 max (char16 param0, char param1);
+OVERLOADABLE short2 max (short2 param0, short param1);
+OVERLOADABLE short3 max (short3 param0, short param1);
+OVERLOADABLE short4 max (short4 param0, short param1);
+OVERLOADABLE short8 max (short8 param0, short param1);
+OVERLOADABLE short16 max (short16 param0, short param1);
+OVERLOADABLE int2 max (int2 param0, int param1);
+OVERLOADABLE int3 max (int3 param0, int param1);
+OVERLOADABLE int4 max (int4 param0, int param1);
+OVERLOADABLE int8 max (int8 param0, int param1);
+OVERLOADABLE int16 max (int16 param0, int param1);
+OVERLOADABLE long2 max (long2 param0, long param1);
+OVERLOADABLE long3 max (long3 param0, long param1);
+OVERLOADABLE long4 max (long4 param0, long param1);
+OVERLOADABLE long8 max (long8 param0, long param1);
+OVERLOADABLE long16 max (long16 param0, long param1);
+OVERLOADABLE uchar2 max (uchar2 param0, uchar param1);
+OVERLOADABLE uchar3 max (uchar3 param0, uchar param1);
+OVERLOADABLE uchar4 max (uchar4 param0, uchar param1);
+OVERLOADABLE uchar8 max (uchar8 param0, uchar param1);
+OVERLOADABLE uchar16 max (uchar16 param0, uchar param1);
+OVERLOADABLE ushort2 max (ushort2 param0, ushort param1);
+OVERLOADABLE ushort3 max (ushort3 param0, ushort param1);
+OVERLOADABLE ushort4 max (ushort4 param0, ushort param1);
+OVERLOADABLE ushort8 max (ushort8 param0, ushort param1);
+OVERLOADABLE ushort16 max (ushort16 param0, ushort param1);
+OVERLOADABLE uint2 max (uint2 param0, uint param1);
+OVERLOADABLE uint3 max (uint3 param0, uint param1);
+OVERLOADABLE uint4 max (uint4 param0, uint param1);
+OVERLOADABLE uint8 max (uint8 param0, uint param1);
+OVERLOADABLE uint16 max (uint16 param0, uint param1);
+OVERLOADABLE ulong2 max (ulong2 param0, ulong param1);
+OVERLOADABLE ulong3 max (ulong3 param0, ulong param1);
+OVERLOADABLE ulong4 max (ulong4 param0, ulong param1);
+OVERLOADABLE ulong8 max (ulong8 param0, ulong param1);
+OVERLOADABLE ulong16 max (ulong16 param0, ulong param1);
+
+//gentype min (gentype x,  gentype y)
+
+OVERLOADABLE char2 min (char2 param0, char2 param1);
+OVERLOADABLE char3 min (char3 param0, char3 param1);
+OVERLOADABLE char4 min (char4 param0, char4 param1);
+OVERLOADABLE char8 min (char8 param0, char8 param1);
+OVERLOADABLE char16 min (char16 param0, char16 param1);
+OVERLOADABLE short2 min (short2 param0, short2 param1);
+OVERLOADABLE short3 min (short3 param0, short3 param1);
+OVERLOADABLE short4 min (short4 param0, short4 param1);
+OVERLOADABLE short8 min (short8 param0, short8 param1);
+OVERLOADABLE short16 min (short16 param0, short16 param1);
+OVERLOADABLE int2 min (int2 param0, int2 param1);
+OVERLOADABLE int3 min (int3 param0, int3 param1);
+OVERLOADABLE int4 min (int4 param0, int4 param1);
+OVERLOADABLE int8 min (int8 param0, int8 param1);
+OVERLOADABLE int16 min (int16 param0, int16 param1);
+OVERLOADABLE long2 min (long2 param0, long2 param1);
+OVERLOADABLE long3 min (long3 param0, long3 param1);
+OVERLOADABLE long4 min (long4 param0, long4 param1);
+OVERLOADABLE long8 min (long8 param0, long8 param1);
+OVERLOADABLE long16 min (long16 param0, long16 param1);
+OVERLOADABLE uchar2 min (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 min (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 min (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 min (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 min (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 min (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 min (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 min (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 min (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 min (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 min (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 min (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 min (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 min (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 min (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 min (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 min (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 min (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 min (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 min (ulong16 param0, ulong16 param1);
+
+//gentype min (gentype x,  sgentype y)
+
+OVERLOADABLE char2 min (char2 param0, char param1);
+OVERLOADABLE char3 min (char3 param0, char param1);
+OVERLOADABLE char4 min (char4 param0, char param1);
+OVERLOADABLE char8 min (char8 param0, char param1);
+OVERLOADABLE char16 min (char16 param0, char param1);
+OVERLOADABLE short2 min (short2 param0, short param1);
+OVERLOADABLE short3 min (short3 param0, short param1);
+OVERLOADABLE short4 min (short4 param0, short param1);
+OVERLOADABLE short8 min (short8 param0, short param1);
+OVERLOADABLE short16 min (short16 param0, short param1);
+OVERLOADABLE int2 min (int2 param0, int param1);
+OVERLOADABLE int3 min (int3 param0, int param1);
+OVERLOADABLE int4 min (int4 param0, int param1);
+OVERLOADABLE int8 min (int8 param0, int param1);
+OVERLOADABLE int16 min (int16 param0, int param1);
+OVERLOADABLE long2 min (long2 param0, long param1);
+OVERLOADABLE long3 min (long3 param0, long param1);
+OVERLOADABLE long4 min (long4 param0, long param1);
+OVERLOADABLE long8 min (long8 param0, long param1);
+OVERLOADABLE long16 min (long16 param0, long param1);
+OVERLOADABLE uchar2 min (uchar2 param0, uchar param1);
+OVERLOADABLE uchar3 min (uchar3 param0, uchar param1);
+OVERLOADABLE uchar4 min (uchar4 param0, uchar param1);
+OVERLOADABLE uchar8 min (uchar8 param0, uchar param1);
+OVERLOADABLE uchar16 min (uchar16 param0, uchar param1);
+OVERLOADABLE ushort2 min (ushort2 param0, ushort param1);
+OVERLOADABLE ushort3 min (ushort3 param0, ushort param1);
+OVERLOADABLE ushort4 min (ushort4 param0, ushort param1);
+OVERLOADABLE ushort8 min (ushort8 param0, ushort param1);
+OVERLOADABLE ushort16 min (ushort16 param0, ushort param1);
+OVERLOADABLE uint2 min (uint2 param0, uint param1);
+OVERLOADABLE uint3 min (uint3 param0, uint param1);
+OVERLOADABLE uint4 min (uint4 param0, uint param1);
+OVERLOADABLE uint8 min (uint8 param0, uint param1);
+OVERLOADABLE uint16 min (uint16 param0, uint param1);
+OVERLOADABLE ulong2 min (ulong2 param0, ulong param1);
+OVERLOADABLE ulong3 min (ulong3 param0, ulong param1);
+OVERLOADABLE ulong4 min (ulong4 param0, ulong param1);
+OVERLOADABLE ulong8 min (ulong8 param0, ulong param1);
+OVERLOADABLE ulong16 min (ulong16 param0, ulong param1);
+
+//gentype mul_hi (gentype x,  gentype y)
+
+OVERLOADABLE char2 mul_hi (char2 param0, char2 param1);
+OVERLOADABLE char3 mul_hi (char3 param0, char3 param1);
+OVERLOADABLE char4 mul_hi (char4 param0, char4 param1);
+OVERLOADABLE char8 mul_hi (char8 param0, char8 param1);
+OVERLOADABLE char16 mul_hi (char16 param0, char16 param1);
+OVERLOADABLE short2 mul_hi (short2 param0, short2 param1);
+OVERLOADABLE short3 mul_hi (short3 param0, short3 param1);
+OVERLOADABLE short4 mul_hi (short4 param0, short4 param1);
+OVERLOADABLE short8 mul_hi (short8 param0, short8 param1);
+OVERLOADABLE short16 mul_hi (short16 param0, short16 param1);
+OVERLOADABLE int2 mul_hi (int2 param0, int2 param1);
+OVERLOADABLE int3 mul_hi (int3 param0, int3 param1);
+OVERLOADABLE int4 mul_hi (int4 param0, int4 param1);
+OVERLOADABLE int8 mul_hi (int8 param0, int8 param1);
+OVERLOADABLE int16 mul_hi (int16 param0, int16 param1);
+OVERLOADABLE long2 mul_hi (long2 param0, long2 param1);
+OVERLOADABLE long3 mul_hi (long3 param0, long3 param1);
+OVERLOADABLE long4 mul_hi (long4 param0, long4 param1);
+OVERLOADABLE long8 mul_hi (long8 param0, long8 param1);
+OVERLOADABLE long16 mul_hi (long16 param0, long16 param1);
+OVERLOADABLE uchar2 mul_hi (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 mul_hi (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 mul_hi (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 mul_hi (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 mul_hi (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 mul_hi (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 mul_hi (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 mul_hi (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 mul_hi (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 mul_hi (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 mul_hi (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 mul_hi (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 mul_hi (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 mul_hi (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 mul_hi (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 mul_hi (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 mul_hi (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 mul_hi (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 mul_hi (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 mul_hi (ulong16 param0, ulong16 param1);
+
+//gentype rotate (gentype v,  gentype i)
+
+OVERLOADABLE char2 rotate (char2 param0, char2 param1);
+OVERLOADABLE char3 rotate (char3 param0, char3 param1);
+OVERLOADABLE char4 rotate (char4 param0, char4 param1);
+OVERLOADABLE char8 rotate (char8 param0, char8 param1);
+OVERLOADABLE char16 rotate (char16 param0, char16 param1);
+OVERLOADABLE short2 rotate (short2 param0, short2 param1);
+OVERLOADABLE short3 rotate (short3 param0, short3 param1);
+OVERLOADABLE short4 rotate (short4 param0, short4 param1);
+OVERLOADABLE short8 rotate (short8 param0, short8 param1);
+OVERLOADABLE short16 rotate (short16 param0, short16 param1);
+OVERLOADABLE int2 rotate (int2 param0, int2 param1);
+OVERLOADABLE int3 rotate (int3 param0, int3 param1);
+OVERLOADABLE int4 rotate (int4 param0, int4 param1);
+OVERLOADABLE int8 rotate (int8 param0, int8 param1);
+OVERLOADABLE int16 rotate (int16 param0, int16 param1);
+OVERLOADABLE long2 rotate (long2 param0, long2 param1);
+OVERLOADABLE long3 rotate (long3 param0, long3 param1);
+OVERLOADABLE long4 rotate (long4 param0, long4 param1);
+OVERLOADABLE long8 rotate (long8 param0, long8 param1);
+OVERLOADABLE long16 rotate (long16 param0, long16 param1);
+OVERLOADABLE uchar2 rotate (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 rotate (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 rotate (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 rotate (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 rotate (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 rotate (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 rotate (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 rotate (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 rotate (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 rotate (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 rotate (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 rotate (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 rotate (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 rotate (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 rotate (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 rotate (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 rotate (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 rotate (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 rotate (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 rotate (ulong16 param0, ulong16 param1);
+
+//gentype sub_sat (gentype x,  gentype y)
+
+OVERLOADABLE char2 sub_sat (char2 param0, char2 param1);
+OVERLOADABLE char3 sub_sat (char3 param0, char3 param1);
+OVERLOADABLE char4 sub_sat (char4 param0, char4 param1);
+OVERLOADABLE char8 sub_sat (char8 param0, char8 param1);
+OVERLOADABLE char16 sub_sat (char16 param0, char16 param1);
+OVERLOADABLE short2 sub_sat (short2 param0, short2 param1);
+OVERLOADABLE short3 sub_sat (short3 param0, short3 param1);
+OVERLOADABLE short4 sub_sat (short4 param0, short4 param1);
+OVERLOADABLE short8 sub_sat (short8 param0, short8 param1);
+OVERLOADABLE short16 sub_sat (short16 param0, short16 param1);
+OVERLOADABLE int2 sub_sat (int2 param0, int2 param1);
+OVERLOADABLE int3 sub_sat (int3 param0, int3 param1);
+OVERLOADABLE int4 sub_sat (int4 param0, int4 param1);
+OVERLOADABLE int8 sub_sat (int8 param0, int8 param1);
+OVERLOADABLE int16 sub_sat (int16 param0, int16 param1);
+OVERLOADABLE long2 sub_sat (long2 param0, long2 param1);
+OVERLOADABLE long3 sub_sat (long3 param0, long3 param1);
+OVERLOADABLE long4 sub_sat (long4 param0, long4 param1);
+OVERLOADABLE long8 sub_sat (long8 param0, long8 param1);
+OVERLOADABLE long16 sub_sat (long16 param0, long16 param1);
+OVERLOADABLE uchar2 sub_sat (uchar2 param0, uchar2 param1);
+OVERLOADABLE uchar3 sub_sat (uchar3 param0, uchar3 param1);
+OVERLOADABLE uchar4 sub_sat (uchar4 param0, uchar4 param1);
+OVERLOADABLE uchar8 sub_sat (uchar8 param0, uchar8 param1);
+OVERLOADABLE uchar16 sub_sat (uchar16 param0, uchar16 param1);
+OVERLOADABLE ushort2 sub_sat (ushort2 param0, ushort2 param1);
+OVERLOADABLE ushort3 sub_sat (ushort3 param0, ushort3 param1);
+OVERLOADABLE ushort4 sub_sat (ushort4 param0, ushort4 param1);
+OVERLOADABLE ushort8 sub_sat (ushort8 param0, ushort8 param1);
+OVERLOADABLE ushort16 sub_sat (ushort16 param0, ushort16 param1);
+OVERLOADABLE uint2 sub_sat (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 sub_sat (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 sub_sat (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 sub_sat (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 sub_sat (uint16 param0, uint16 param1);
+OVERLOADABLE ulong2 sub_sat (ulong2 param0, ulong2 param1);
+OVERLOADABLE ulong3 sub_sat (ulong3 param0, ulong3 param1);
+OVERLOADABLE ulong4 sub_sat (ulong4 param0, ulong4 param1);
+OVERLOADABLE ulong8 sub_sat (ulong8 param0, ulong8 param1);
+OVERLOADABLE ulong16 sub_sat (ulong16 param0, ulong16 param1);
+
+//shortn upsample (charn hi, ucharn lo)
+
+OVERLOADABLE short2 upsample (char2 param0, uchar2 param1);
+OVERLOADABLE short3 upsample (char3 param0, uchar3 param1);
+OVERLOADABLE short4 upsample (char4 param0, uchar4 param1);
+OVERLOADABLE short8 upsample (char8 param0, uchar8 param1);
+OVERLOADABLE short16 upsample (char16 param0, uchar16 param1);
+
+//ushortn upsample (ucharn hi, ucharn lo)
+
+OVERLOADABLE ushort2 upsample (uchar2 param0, uchar2 param1);
+OVERLOADABLE ushort3 upsample (uchar3 param0, uchar3 param1);
+OVERLOADABLE ushort4 upsample (uchar4 param0, uchar4 param1);
+OVERLOADABLE ushort8 upsample (uchar8 param0, uchar8 param1);
+OVERLOADABLE ushort16 upsample (uchar16 param0, uchar16 param1);
+
+//intn upsample (shortn hi, ushortn lo)
+
+OVERLOADABLE int2 upsample (short2 param0, ushort2 param1);
+OVERLOADABLE int3 upsample (short3 param0, ushort3 param1);
+OVERLOADABLE int4 upsample (short4 param0, ushort4 param1);
+OVERLOADABLE int8 upsample (short8 param0, ushort8 param1);
+OVERLOADABLE int16 upsample (short16 param0, ushort16 param1);
+
+//uintn upsample (ushortn hi, ushortn lo)
+
+OVERLOADABLE uint2 upsample (ushort2 param0, ushort2 param1);
+OVERLOADABLE uint3 upsample (ushort3 param0, ushort3 param1);
+OVERLOADABLE uint4 upsample (ushort4 param0, ushort4 param1);
+OVERLOADABLE uint8 upsample (ushort8 param0, ushort8 param1);
+OVERLOADABLE uint16 upsample (ushort16 param0, ushort16 param1);
+
+//longn upsample (intn hi, uintn lo)
+
+OVERLOADABLE long2 upsample (int2 param0, uint2 param1);
+OVERLOADABLE long3 upsample (int3 param0, uint3 param1);
+OVERLOADABLE long4 upsample (int4 param0, uint4 param1);
+OVERLOADABLE long8 upsample (int8 param0, uint8 param1);
+OVERLOADABLE long16 upsample (int16 param0, uint16 param1);
+
+//ulongn upsample (uintn hi, uintn lo)
+
+OVERLOADABLE ulong2 upsample (uint2 param0, uint2 param1);
+OVERLOADABLE ulong3 upsample (uint3 param0, uint3 param1);
+OVERLOADABLE ulong4 upsample (uint4 param0, uint4 param1);
+OVERLOADABLE ulong8 upsample (uint8 param0, uint8 param1);
+OVERLOADABLE ulong16 upsample (uint16 param0, uint16 param1);
+
+//gentype popcount (gentype x)
+
+OVERLOADABLE char2 popcount (char2 param0);
+OVERLOADABLE char3 popcount (char3 param0);
+OVERLOADABLE char4 popcount (char4 param0);
+OVERLOADABLE char8 popcount (char8 param0);
+OVERLOADABLE char16 popcount (char16 param0);
+OVERLOADABLE short2 popcount (short2 param0);
+OVERLOADABLE short3 popcount (short3 param0);
+OVERLOADABLE short4 popcount (short4 param0);
+OVERLOADABLE short8 popcount (short8 param0);
+OVERLOADABLE short16 popcount (short16 param0);
+OVERLOADABLE int2 popcount (int2 param0);
+OVERLOADABLE int3 popcount (int3 param0);
+OVERLOADABLE int4 popcount (int4 param0);
+OVERLOADABLE int8 popcount (int8 param0);
+OVERLOADABLE int16 popcount (int16 param0);
+OVERLOADABLE long2 popcount (long2 param0);
+OVERLOADABLE long3 popcount (long3 param0);
+OVERLOADABLE long4 popcount (long4 param0);
+OVERLOADABLE long8 popcount (long8 param0);
+OVERLOADABLE long16 popcount (long16 param0);
+OVERLOADABLE uchar2 popcount (uchar2 param0);
+OVERLOADABLE uchar3 popcount (uchar3 param0);
+OVERLOADABLE uchar4 popcount (uchar4 param0);
+OVERLOADABLE uchar8 popcount (uchar8 param0);
+OVERLOADABLE uchar16 popcount (uchar16 param0);
+OVERLOADABLE ushort2 popcount (ushort2 param0);
+OVERLOADABLE ushort3 popcount (ushort3 param0);
+OVERLOADABLE ushort4 popcount (ushort4 param0);
+OVERLOADABLE ushort8 popcount (ushort8 param0);
+OVERLOADABLE ushort16 popcount (ushort16 param0);
+OVERLOADABLE uint2 popcount (uint2 param0);
+OVERLOADABLE uint3 popcount (uint3 param0);
+OVERLOADABLE uint4 popcount (uint4 param0);
+OVERLOADABLE uint8 popcount (uint8 param0);
+OVERLOADABLE uint16 popcount (uint16 param0);
+OVERLOADABLE ulong2 popcount (ulong2 param0);
+OVERLOADABLE ulong3 popcount (ulong3 param0);
+OVERLOADABLE ulong4 popcount (ulong4 param0);
+OVERLOADABLE ulong8 popcount (ulong8 param0);
+OVERLOADABLE ulong16 popcount (ulong16 param0);
+
+//fast_integer builtin functions
+//gentype mad24 (gentype x, gentype y, gentype z)
+
+OVERLOADABLE uint2 mad24 (uint2 param0, uint2 param1, uint2 param2);
+OVERLOADABLE uint3 mad24 (uint3 param0, uint3 param1, uint3 param2);
+OVERLOADABLE uint4 mad24 (uint4 param0, uint4 param1, uint4 param2);
+OVERLOADABLE uint8 mad24 (uint8 param0, uint8 param1, uint8 param2);
+OVERLOADABLE uint16 mad24 (uint16 param0, uint16 param1, uint16 param2);
+OVERLOADABLE int2 mad24 (int2 param0, int2 param1, int2 param2);
+OVERLOADABLE int3 mad24 (int3 param0, int3 param1, int3 param2);
+OVERLOADABLE int4 mad24 (int4 param0, int4 param1, int4 param2);
+OVERLOADABLE int8 mad24 (int8 param0, int8 param1, int8 param2);
+OVERLOADABLE int16 mad24 (int16 param0, int16 param1, int16 param2);
+
+//gentype mul24 (gentype x, gentype y)
+
+OVERLOADABLE uint2 mul24 (uint2 param0, uint2 param1);
+OVERLOADABLE uint3 mul24 (uint3 param0, uint3 param1);
+OVERLOADABLE uint4 mul24 (uint4 param0, uint4 param1);
+OVERLOADABLE uint8 mul24 (uint8 param0, uint8 param1);
+OVERLOADABLE uint16 mul24 (uint16 param0, uint16 param1);
+OVERLOADABLE int2 mul24 (int2 param0, int2 param1);
+OVERLOADABLE int3 mul24 (int3 param0, int3 param1);
+OVERLOADABLE int4 mul24 (int4 param0, int4 param1);
+OVERLOADABLE int8 mul24 (int8 param0, int8 param1);
+OVERLOADABLE int16 mul24 (int16 param0, int16 param1);
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_math.h b/drivers/pocl-gen7/lib/beignet/include/ocl_math.h
new file mode 100644
index 0000000..7ce2fc7
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_math.h
@@ -0,0 +1,549 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_MATH_H__
+#define __OCL_MATH_H__
+
+#include "ocl_types.h"
+#include "ocl_math_common.h"
+
+
+OVERLOADABLE float lgamma_r(float x, global int *signgamp);
+OVERLOADABLE float lgamma_r(float x, local int *signgamp);
+OVERLOADABLE float lgamma_r(float x, private int *signgamp);
+OVERLOADABLE float sincos(float x, global float *cosval);
+OVERLOADABLE float sincos(float x, local float *cosval);
+OVERLOADABLE float sincos(float x, private float *cosval);
+OVERLOADABLE float frexp(float x, global int *exp);
+OVERLOADABLE float frexp(float x, local int *exp);
+OVERLOADABLE float frexp(float x, private int *exp);
+OVERLOADABLE float modf(float x, global float *i);
+OVERLOADABLE float modf(float x, local float *i);
+OVERLOADABLE float modf(float x, private float *i);
+OVERLOADABLE float fract(float x, global float *p);
+OVERLOADABLE float fract(float x, local float *p);
+OVERLOADABLE float fract(float x, private float *p);
+OVERLOADABLE float remquo(float x, float y, global int *quo);
+OVERLOADABLE float remquo(float x, float y, local int *quo);
+OVERLOADABLE float remquo(float x, float y, private int *quo);
+
+
+OVERLOADABLE half lgamma_r(half x, global int *signgamp);
+OVERLOADABLE half lgamma_r(half x, local int *signgamp);
+OVERLOADABLE half lgamma_r(half x, private int *signgamp);
+OVERLOADABLE half sincos(half x, global half *cosval);
+OVERLOADABLE half sincos(half x, local half *cosval);
+OVERLOADABLE half sincos(half x, private half *cosval);
+OVERLOADABLE half frexp(half x, global int *exp);
+OVERLOADABLE half frexp(half x, local int *exp);
+OVERLOADABLE half frexp(half x, private int *exp);
+OVERLOADABLE half modf(half x, global half *i);
+OVERLOADABLE half modf(half x, local half *i);
+OVERLOADABLE half modf(half x, private half *i);
+OVERLOADABLE half fract(half x, global half *p);
+OVERLOADABLE half fract(half x, local half *p);
+OVERLOADABLE half fract(half x, private half *p);
+OVERLOADABLE half remquo(half x, half y, global int *quo);
+OVERLOADABLE half remquo(half x, half y, local int *quo);
+OVERLOADABLE half remquo(half x, half y, private int *quo);
+
+
+
+//------- double -----------
+OVERLOADABLE double fract(double x, global double *p);
+OVERLOADABLE double fract(double x, local double *p);
+OVERLOADABLE double fract(double x, private double *p);
+OVERLOADABLE double frexp(double x, global int *exp);
+OVERLOADABLE double frexp(double x, local int *exp);
+OVERLOADABLE double frexp(double x, private int *exp);
+OVERLOADABLE double lgamma_r(double x, global int *signgamp);
+OVERLOADABLE double lgamma_r(double x, local int *signgamp);
+OVERLOADABLE double lgamma_r(double x, private int *signgamp);
+OVERLOADABLE double modf(double x, global double *i);
+OVERLOADABLE double modf(double x, local double *i);
+OVERLOADABLE double modf(double x, private double *i);
+OVERLOADABLE double remquo(double x, double y, global int *quo);
+OVERLOADABLE double remquo(double x, double y, local int *quo);
+OVERLOADABLE double remquo(double x, double y, private int *quo);
+OVERLOADABLE double sincos(double x, global double *cosval);
+OVERLOADABLE double sincos(double x, local double *cosval);
+OVERLOADABLE double sincos(double x, private double *cosval);
+
+
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//math builtin functions
+//gentype fract (gentype x, __global gentype *iptr)
+
+OVERLOADABLE float2 fract (float2 param0, __global float2 *param1);
+OVERLOADABLE float3 fract (float3 param0, __global float3 *param1);
+OVERLOADABLE float4 fract (float4 param0, __global float4 *param1);
+OVERLOADABLE float8 fract (float8 param0, __global float8 *param1);
+OVERLOADABLE float16 fract (float16 param0, __global float16 *param1);
+OVERLOADABLE double2 fract (double2 param0, __global double2 *param1);
+OVERLOADABLE double3 fract (double3 param0, __global double3 *param1);
+OVERLOADABLE double4 fract (double4 param0, __global double4 *param1);
+OVERLOADABLE double8 fract (double8 param0, __global double8 *param1);
+OVERLOADABLE double16 fract (double16 param0, __global double16 *param1);
+OVERLOADABLE half2 fract (half2 param0, __global half2 *param1);
+OVERLOADABLE half3 fract (half3 param0, __global half3 *param1);
+OVERLOADABLE half4 fract (half4 param0, __global half4 *param1);
+OVERLOADABLE half8 fract (half8 param0, __global half8 *param1);
+OVERLOADABLE half16 fract (half16 param0, __global half16 *param1);
+
+//gentype fract (gentype x, __local gentype *iptr)
+
+OVERLOADABLE float2 fract (float2 param0, __local float2 *param1);
+OVERLOADABLE float3 fract (float3 param0, __local float3 *param1);
+OVERLOADABLE float4 fract (float4 param0, __local float4 *param1);
+OVERLOADABLE float8 fract (float8 param0, __local float8 *param1);
+OVERLOADABLE float16 fract (float16 param0, __local float16 *param1);
+OVERLOADABLE double2 fract (double2 param0, __local double2 *param1);
+OVERLOADABLE double3 fract (double3 param0, __local double3 *param1);
+OVERLOADABLE double4 fract (double4 param0, __local double4 *param1);
+OVERLOADABLE double8 fract (double8 param0, __local double8 *param1);
+OVERLOADABLE double16 fract (double16 param0, __local double16 *param1);
+OVERLOADABLE half2 fract (half2 param0, __local half2 *param1);
+OVERLOADABLE half3 fract (half3 param0, __local half3 *param1);
+OVERLOADABLE half4 fract (half4 param0, __local half4 *param1);
+OVERLOADABLE half8 fract (half8 param0, __local half8 *param1);
+OVERLOADABLE half16 fract (half16 param0, __local half16 *param1);
+
+//gentype fract (gentype x, __private gentype *iptr)
+
+OVERLOADABLE float2 fract (float2 param0, __private float2 *param1);
+OVERLOADABLE float3 fract (float3 param0, __private float3 *param1);
+OVERLOADABLE float4 fract (float4 param0, __private float4 *param1);
+OVERLOADABLE float8 fract (float8 param0, __private float8 *param1);
+OVERLOADABLE float16 fract (float16 param0, __private float16 *param1);
+OVERLOADABLE double2 fract (double2 param0, __private double2 *param1);
+OVERLOADABLE double3 fract (double3 param0, __private double3 *param1);
+OVERLOADABLE double4 fract (double4 param0, __private double4 *param1);
+OVERLOADABLE double8 fract (double8 param0, __private double8 *param1);
+OVERLOADABLE double16 fract (double16 param0, __private double16 *param1);
+OVERLOADABLE half2 fract (half2 param0, __private half2 *param1);
+OVERLOADABLE half3 fract (half3 param0, __private half3 *param1);
+OVERLOADABLE half4 fract (half4 param0, __private half4 *param1);
+OVERLOADABLE half8 fract (half8 param0, __private half8 *param1);
+OVERLOADABLE half16 fract (half16 param0, __private half16 *param1);
+
+//floatn frexp (floatn x, __global intn *exp)
+
+OVERLOADABLE float2 frexp (float2 param0, __global int2 *param1);
+OVERLOADABLE float3 frexp (float3 param0, __global int3 *param1);
+OVERLOADABLE float4 frexp (float4 param0, __global int4 *param1);
+OVERLOADABLE float8 frexp (float8 param0, __global int8 *param1);
+OVERLOADABLE float16 frexp (float16 param0, __global int16 *param1);
+
+//floatn frexp (floatn x, __local intn *exp)
+
+OVERLOADABLE float2 frexp (float2 param0, __local int2 *param1);
+OVERLOADABLE float3 frexp (float3 param0, __local int3 *param1);
+OVERLOADABLE float4 frexp (float4 param0, __local int4 *param1);
+OVERLOADABLE float8 frexp (float8 param0, __local int8 *param1);
+OVERLOADABLE float16 frexp (float16 param0, __local int16 *param1);
+
+//floatn frexp (floatn x, __private intn *exp)
+
+OVERLOADABLE float2 frexp (float2 param0, __private int2 *param1);
+OVERLOADABLE float3 frexp (float3 param0, __private int3 *param1);
+OVERLOADABLE float4 frexp (float4 param0, __private int4 *param1);
+OVERLOADABLE float8 frexp (float8 param0, __private int8 *param1);
+OVERLOADABLE float16 frexp (float16 param0, __private int16 *param1);
+
+//float frexp (float x, __global int *exp)
+
+
+//float frexp (float x, __local int *exp)
+
+
+//float frexp (float x, __private int *exp)
+
+
+//halfn frexp (halfn x, __global intn *exp)
+
+OVERLOADABLE half2 frexp (half2 param0, __global int2 *param1);
+OVERLOADABLE half3 frexp (half3 param0, __global int3 *param1);
+OVERLOADABLE half4 frexp (half4 param0, __global int4 *param1);
+OVERLOADABLE half8 frexp (half8 param0, __global int8 *param1);
+OVERLOADABLE half16 frexp (half16 param0, __global int16 *param1);
+
+//halfn frexp (halfn x, __local intn *exp)
+
+OVERLOADABLE half2 frexp (half2 param0, __local int2 *param1);
+OVERLOADABLE half3 frexp (half3 param0, __local int3 *param1);
+OVERLOADABLE half4 frexp (half4 param0, __local int4 *param1);
+OVERLOADABLE half8 frexp (half8 param0, __local int8 *param1);
+OVERLOADABLE half16 frexp (half16 param0, __local int16 *param1);
+
+//halfn frexp (halfn x, __private intn *exp)
+
+OVERLOADABLE half2 frexp (half2 param0, __private int2 *param1);
+OVERLOADABLE half3 frexp (half3 param0, __private int3 *param1);
+OVERLOADABLE half4 frexp (half4 param0, __private int4 *param1);
+OVERLOADABLE half8 frexp (half8 param0, __private int8 *param1);
+OVERLOADABLE half16 frexp (half16 param0, __private int16 *param1);
+
+//half frexp (half x, __global int *exp)
+
+
+//half frexp (half x, __local int *exp)
+
+
+//half frexp (half x, __private int *exp)
+
+
+//doublen frexp (doublen x, __global intn *exp)
+
+OVERLOADABLE double2 frexp (double2 param0, __global int2 *param1);
+OVERLOADABLE double3 frexp (double3 param0, __global int3 *param1);
+OVERLOADABLE double4 frexp (double4 param0, __global int4 *param1);
+OVERLOADABLE double8 frexp (double8 param0, __global int8 *param1);
+OVERLOADABLE double16 frexp (double16 param0, __global int16 *param1);
+
+//doublen frexp (doublen x, __local intn *exp)
+
+OVERLOADABLE double2 frexp (double2 param0, __local int2 *param1);
+OVERLOADABLE double3 frexp (double3 param0, __local int3 *param1);
+OVERLOADABLE double4 frexp (double4 param0, __local int4 *param1);
+OVERLOADABLE double8 frexp (double8 param0, __local int8 *param1);
+OVERLOADABLE double16 frexp (double16 param0, __local int16 *param1);
+
+//doublen frexp (doublen x, __private intn *exp)
+
+OVERLOADABLE double2 frexp (double2 param0, __private int2 *param1);
+OVERLOADABLE double3 frexp (double3 param0, __private int3 *param1);
+OVERLOADABLE double4 frexp (double4 param0, __private int4 *param1);
+OVERLOADABLE double8 frexp (double8 param0, __private int8 *param1);
+OVERLOADABLE double16 frexp (double16 param0, __private int16 *param1);
+
+//double frexp (double x, __global int *exp)
+
+
+//double frexp (double x, __local int *exp)
+
+
+//double frexp (double x, __private int *exp)
+
+
+//floatn lgamma_r (floatn x, __global intn *signp)
+
+OVERLOADABLE float2 lgamma_r (float2 param0, __global int2 *param1);
+OVERLOADABLE float3 lgamma_r (float3 param0, __global int3 *param1);
+OVERLOADABLE float4 lgamma_r (float4 param0, __global int4 *param1);
+OVERLOADABLE float8 lgamma_r (float8 param0, __global int8 *param1);
+OVERLOADABLE float16 lgamma_r (float16 param0, __global int16 *param1);
+
+//floatn lgamma_r (floatn x, __local intn *signp)
+
+OVERLOADABLE float2 lgamma_r (float2 param0, __local int2 *param1);
+OVERLOADABLE float3 lgamma_r (float3 param0, __local int3 *param1);
+OVERLOADABLE float4 lgamma_r (float4 param0, __local int4 *param1);
+OVERLOADABLE float8 lgamma_r (float8 param0, __local int8 *param1);
+OVERLOADABLE float16 lgamma_r (float16 param0, __local int16 *param1);
+
+//floatn lgamma_r (floatn x, __private intn *signp)
+
+OVERLOADABLE float2 lgamma_r (float2 param0, __private int2 *param1);
+OVERLOADABLE float3 lgamma_r (float3 param0, __private int3 *param1);
+OVERLOADABLE float4 lgamma_r (float4 param0, __private int4 *param1);
+OVERLOADABLE float8 lgamma_r (float8 param0, __private int8 *param1);
+OVERLOADABLE float16 lgamma_r (float16 param0, __private int16 *param1);
+
+//float lgamma_r (float x, __global int *signp)
+
+
+//float lgamma_r (float x, __local int *signp)
+
+
+//float lgamma_r (float x,   __private int *signp)
+
+
+//halfn lgamma_r (halfn x, __global intn *signp)
+
+OVERLOADABLE half2 lgamma_r (half2 param0, __global int2 *param1);
+OVERLOADABLE half3 lgamma_r (half3 param0, __global int3 *param1);
+OVERLOADABLE half4 lgamma_r (half4 param0, __global int4 *param1);
+OVERLOADABLE half8 lgamma_r (half8 param0, __global int8 *param1);
+OVERLOADABLE half16 lgamma_r (half16 param0, __global int16 *param1);
+
+//halfn lgamma_r (halfn x, __local intn *signp)
+
+OVERLOADABLE half2 lgamma_r (half2 param0, __local int2 *param1);
+OVERLOADABLE half3 lgamma_r (half3 param0, __local int3 *param1);
+OVERLOADABLE half4 lgamma_r (half4 param0, __local int4 *param1);
+OVERLOADABLE half8 lgamma_r (half8 param0, __local int8 *param1);
+OVERLOADABLE half16 lgamma_r (half16 param0, __local int16 *param1);
+
+//halfn lgamma_r (halfn x, __private intn *signp)
+
+OVERLOADABLE half2 lgamma_r (half2 param0, __private int2 *param1);
+OVERLOADABLE half3 lgamma_r (half3 param0, __private int3 *param1);
+OVERLOADABLE half4 lgamma_r (half4 param0, __private int4 *param1);
+OVERLOADABLE half8 lgamma_r (half8 param0, __private int8 *param1);
+OVERLOADABLE half16 lgamma_r (half16 param0, __private int16 *param1);
+
+//half lgamma_r (half x, __global int *signp)
+
+
+//half lgamma_r (half x, __local int *signp)
+
+
+//half lgamma_r (half x,   __private int *signp)
+
+
+//doublen lgamma_r (doublen x, __global intn *signp)
+
+OVERLOADABLE double2 lgamma_r (double2 param0, __global int2 *param1);
+OVERLOADABLE double3 lgamma_r (double3 param0, __global int3 *param1);
+OVERLOADABLE double4 lgamma_r (double4 param0, __global int4 *param1);
+OVERLOADABLE double8 lgamma_r (double8 param0, __global int8 *param1);
+OVERLOADABLE double16 lgamma_r (double16 param0, __global int16 *param1);
+
+//doublen lgamma_r (doublen x, __local intn *signp)
+
+OVERLOADABLE double2 lgamma_r (double2 param0, __local int2 *param1);
+OVERLOADABLE double3 lgamma_r (double3 param0, __local int3 *param1);
+OVERLOADABLE double4 lgamma_r (double4 param0, __local int4 *param1);
+OVERLOADABLE double8 lgamma_r (double8 param0, __local int8 *param1);
+OVERLOADABLE double16 lgamma_r (double16 param0, __local int16 *param1);
+
+//doublen lgamma_r (doublen x, __private intn *signp)
+
+OVERLOADABLE double2 lgamma_r (double2 param0, __private int2 *param1);
+OVERLOADABLE double3 lgamma_r (double3 param0, __private int3 *param1);
+OVERLOADABLE double4 lgamma_r (double4 param0, __private int4 *param1);
+OVERLOADABLE double8 lgamma_r (double8 param0, __private int8 *param1);
+OVERLOADABLE double16 lgamma_r (double16 param0, __private int16 *param1);
+
+//double lgamma_r (double x, __global int *signp)
+
+
+//double lgamma_r (double x, __local int *signp)
+
+
+//double lgamma_r (double x, __private int *signp)
+
+
+//gentype modf (gentype x, __global gentype *iptr)
+
+OVERLOADABLE float2 modf (float2 param0, __global float2 *param1);
+OVERLOADABLE float3 modf (float3 param0, __global float3 *param1);
+OVERLOADABLE float4 modf (float4 param0, __global float4 *param1);
+OVERLOADABLE float8 modf (float8 param0, __global float8 *param1);
+OVERLOADABLE float16 modf (float16 param0, __global float16 *param1);
+OVERLOADABLE double2 modf (double2 param0, __global double2 *param1);
+OVERLOADABLE double3 modf (double3 param0, __global double3 *param1);
+OVERLOADABLE double4 modf (double4 param0, __global double4 *param1);
+OVERLOADABLE double8 modf (double8 param0, __global double8 *param1);
+OVERLOADABLE double16 modf (double16 param0, __global double16 *param1);
+OVERLOADABLE half2 modf (half2 param0, __global half2 *param1);
+OVERLOADABLE half3 modf (half3 param0, __global half3 *param1);
+OVERLOADABLE half4 modf (half4 param0, __global half4 *param1);
+OVERLOADABLE half8 modf (half8 param0, __global half8 *param1);
+OVERLOADABLE half16 modf (half16 param0, __global half16 *param1);
+
+//gentype modf (gentype x, __local gentype *iptr)
+
+OVERLOADABLE float2 modf (float2 param0, __local float2 *param1);
+OVERLOADABLE float3 modf (float3 param0, __local float3 *param1);
+OVERLOADABLE float4 modf (float4 param0, __local float4 *param1);
+OVERLOADABLE float8 modf (float8 param0, __local float8 *param1);
+OVERLOADABLE float16 modf (float16 param0, __local float16 *param1);
+OVERLOADABLE double2 modf (double2 param0, __local double2 *param1);
+OVERLOADABLE double3 modf (double3 param0, __local double3 *param1);
+OVERLOADABLE double4 modf (double4 param0, __local double4 *param1);
+OVERLOADABLE double8 modf (double8 param0, __local double8 *param1);
+OVERLOADABLE double16 modf (double16 param0, __local double16 *param1);
+OVERLOADABLE half2 modf (half2 param0, __local half2 *param1);
+OVERLOADABLE half3 modf (half3 param0, __local half3 *param1);
+OVERLOADABLE half4 modf (half4 param0, __local half4 *param1);
+OVERLOADABLE half8 modf (half8 param0, __local half8 *param1);
+OVERLOADABLE half16 modf (half16 param0, __local half16 *param1);
+
+//gentype modf (gentype x, __private gentype *iptr)
+
+OVERLOADABLE float2 modf (float2 param0, __private float2 *param1);
+OVERLOADABLE float3 modf (float3 param0, __private float3 *param1);
+OVERLOADABLE float4 modf (float4 param0, __private float4 *param1);
+OVERLOADABLE float8 modf (float8 param0, __private float8 *param1);
+OVERLOADABLE float16 modf (float16 param0, __private float16 *param1);
+OVERLOADABLE double2 modf (double2 param0, __private double2 *param1);
+OVERLOADABLE double3 modf (double3 param0, __private double3 *param1);
+OVERLOADABLE double4 modf (double4 param0, __private double4 *param1);
+OVERLOADABLE double8 modf (double8 param0, __private double8 *param1);
+OVERLOADABLE double16 modf (double16 param0, __private double16 *param1);
+OVERLOADABLE half2 modf (half2 param0, __private half2 *param1);
+OVERLOADABLE half3 modf (half3 param0, __private half3 *param1);
+OVERLOADABLE half4 modf (half4 param0, __private half4 *param1);
+OVERLOADABLE half8 modf (half8 param0, __private half8 *param1);
+OVERLOADABLE half16 modf (half16 param0, __private half16 *param1);
+
+//floatn remquo (floatn x, floatn y, __global intn *quo)
+
+OVERLOADABLE float2 remquo (float2 param0, float2 param1, __global int2 *param2);
+OVERLOADABLE float3 remquo (float3 param0, float3 param1, __global int3 *param2);
+OVERLOADABLE float4 remquo (float4 param0, float4 param1, __global int4 *param2);
+OVERLOADABLE float8 remquo (float8 param0, float8 param1, __global int8 *param2);
+OVERLOADABLE float16 remquo (float16 param0, float16 param1, __global int16 *param2);
+
+//floatn remquo (floatn x, floatn y, __local intn *quo)
+
+OVERLOADABLE float2 remquo (float2 param0, float2 param1, __local int2 *param2);
+OVERLOADABLE float3 remquo (float3 param0, float3 param1, __local int3 *param2);
+OVERLOADABLE float4 remquo (float4 param0, float4 param1, __local int4 *param2);
+OVERLOADABLE float8 remquo (float8 param0, float8 param1, __local int8 *param2);
+OVERLOADABLE float16 remquo (float16 param0, float16 param1, __local int16 *param2);
+
+//floatn remquo (floatn x, floatn y, __private intn *quo)
+
+OVERLOADABLE float2 remquo (float2 param0, float2 param1, __private int2 *param2);
+OVERLOADABLE float3 remquo (float3 param0, float3 param1, __private int3 *param2);
+OVERLOADABLE float4 remquo (float4 param0, float4 param1, __private int4 *param2);
+OVERLOADABLE float8 remquo (float8 param0, float8 param1, __private int8 *param2);
+OVERLOADABLE float16 remquo (float16 param0, float16 param1, __private int16 *param2);
+
+//float remquo (float x, float y, __global int *quo)
+
+
+//float remquo (float x, float y, __local int *quo)
+
+
+//float remquo (float x, float y, __private int *quo)
+
+
+//halfn remquo (halfn x, halfn y, __global intn *quo)
+
+OVERLOADABLE half2 remquo (half2 param0, half2 param1, __global int2 *param2);
+OVERLOADABLE half3 remquo (half3 param0, half3 param1, __global int3 *param2);
+OVERLOADABLE half4 remquo (half4 param0, half4 param1, __global int4 *param2);
+OVERLOADABLE half8 remquo (half8 param0, half8 param1, __global int8 *param2);
+OVERLOADABLE half16 remquo (half16 param0, half16 param1, __global int16 *param2);
+
+//halfn remquo (halfn x, halfn y, __local intn *quo)
+
+OVERLOADABLE half2 remquo (half2 param0, half2 param1, __local int2 *param2);
+OVERLOADABLE half3 remquo (half3 param0, half3 param1, __local int3 *param2);
+OVERLOADABLE half4 remquo (half4 param0, half4 param1, __local int4 *param2);
+OVERLOADABLE half8 remquo (half8 param0, half8 param1, __local int8 *param2);
+OVERLOADABLE half16 remquo (half16 param0, half16 param1, __local int16 *param2);
+
+//halfn remquo (halfn x, halfn y, __private intn *quo)
+
+OVERLOADABLE half2 remquo (half2 param0, half2 param1, __private int2 *param2);
+OVERLOADABLE half3 remquo (half3 param0, half3 param1, __private int3 *param2);
+OVERLOADABLE half4 remquo (half4 param0, half4 param1, __private int4 *param2);
+OVERLOADABLE half8 remquo (half8 param0, half8 param1, __private int8 *param2);
+OVERLOADABLE half16 remquo (half16 param0, half16 param1, __private int16 *param2);
+
+//half remquo (half x, half y, __global int *quo)
+
+
+//half remquo (half x, half y, __local int *quo)
+
+
+//half remquo (half x, half y, __private int *quo)
+
+
+//doublen remquo (doublen x, doublen y, __global intn *quo)
+
+OVERLOADABLE double2 remquo (double2 param0, double2 param1, __global int2 *param2);
+OVERLOADABLE double3 remquo (double3 param0, double3 param1, __global int3 *param2);
+OVERLOADABLE double4 remquo (double4 param0, double4 param1, __global int4 *param2);
+OVERLOADABLE double8 remquo (double8 param0, double8 param1, __global int8 *param2);
+OVERLOADABLE double16 remquo (double16 param0, double16 param1, __global int16 *param2);
+
+//doublen remquo (doublen x, doublen y, __local intn *quo)
+
+OVERLOADABLE double2 remquo (double2 param0, double2 param1, __local int2 *param2);
+OVERLOADABLE double3 remquo (double3 param0, double3 param1, __local int3 *param2);
+OVERLOADABLE double4 remquo (double4 param0, double4 param1, __local int4 *param2);
+OVERLOADABLE double8 remquo (double8 param0, double8 param1, __local int8 *param2);
+OVERLOADABLE double16 remquo (double16 param0, double16 param1, __local int16 *param2);
+
+//doublen remquo (doublen x, doublen y, __private intn *quo)
+
+OVERLOADABLE double2 remquo (double2 param0, double2 param1, __private int2 *param2);
+OVERLOADABLE double3 remquo (double3 param0, double3 param1, __private int3 *param2);
+OVERLOADABLE double4 remquo (double4 param0, double4 param1, __private int4 *param2);
+OVERLOADABLE double8 remquo (double8 param0, double8 param1, __private int8 *param2);
+OVERLOADABLE double16 remquo (double16 param0, double16 param1, __private int16 *param2);
+
+//double remquo (double x, double y, __global int *quo)
+
+
+//double remquo (double x, double y, __local int *quo)
+
+
+//double remquo (double x, double y, __private int *quo)
+
+
+//gentype sincos (gentype x, __global gentype *cosval)
+
+OVERLOADABLE float2 sincos (float2 param0, __global float2 *param1);
+OVERLOADABLE float3 sincos (float3 param0, __global float3 *param1);
+OVERLOADABLE float4 sincos (float4 param0, __global float4 *param1);
+OVERLOADABLE float8 sincos (float8 param0, __global float8 *param1);
+OVERLOADABLE float16 sincos (float16 param0, __global float16 *param1);
+OVERLOADABLE double2 sincos (double2 param0, __global double2 *param1);
+OVERLOADABLE double3 sincos (double3 param0, __global double3 *param1);
+OVERLOADABLE double4 sincos (double4 param0, __global double4 *param1);
+OVERLOADABLE double8 sincos (double8 param0, __global double8 *param1);
+OVERLOADABLE double16 sincos (double16 param0, __global double16 *param1);
+OVERLOADABLE half2 sincos (half2 param0, __global half2 *param1);
+OVERLOADABLE half3 sincos (half3 param0, __global half3 *param1);
+OVERLOADABLE half4 sincos (half4 param0, __global half4 *param1);
+OVERLOADABLE half8 sincos (half8 param0, __global half8 *param1);
+OVERLOADABLE half16 sincos (half16 param0, __global half16 *param1);
+
+//gentype sincos (gentype x, __local gentype *cosval)
+
+OVERLOADABLE float2 sincos (float2 param0, __local float2 *param1);
+OVERLOADABLE float3 sincos (float3 param0, __local float3 *param1);
+OVERLOADABLE float4 sincos (float4 param0, __local float4 *param1);
+OVERLOADABLE float8 sincos (float8 param0, __local float8 *param1);
+OVERLOADABLE float16 sincos (float16 param0, __local float16 *param1);
+OVERLOADABLE double2 sincos (double2 param0, __local double2 *param1);
+OVERLOADABLE double3 sincos (double3 param0, __local double3 *param1);
+OVERLOADABLE double4 sincos (double4 param0, __local double4 *param1);
+OVERLOADABLE double8 sincos (double8 param0, __local double8 *param1);
+OVERLOADABLE double16 sincos (double16 param0, __local double16 *param1);
+OVERLOADABLE half2 sincos (half2 param0, __local half2 *param1);
+OVERLOADABLE half3 sincos (half3 param0, __local half3 *param1);
+OVERLOADABLE half4 sincos (half4 param0, __local half4 *param1);
+OVERLOADABLE half8 sincos (half8 param0, __local half8 *param1);
+OVERLOADABLE half16 sincos (half16 param0, __local half16 *param1);
+
+//gentype sincos (gentype x, __private gentype *cosval)
+
+OVERLOADABLE float2 sincos (float2 param0, __private float2 *param1);
+OVERLOADABLE float3 sincos (float3 param0, __private float3 *param1);
+OVERLOADABLE float4 sincos (float4 param0, __private float4 *param1);
+OVERLOADABLE float8 sincos (float8 param0, __private float8 *param1);
+OVERLOADABLE float16 sincos (float16 param0, __private float16 *param1);
+OVERLOADABLE double2 sincos (double2 param0, __private double2 *param1);
+OVERLOADABLE double3 sincos (double3 param0, __private double3 *param1);
+OVERLOADABLE double4 sincos (double4 param0, __private double4 *param1);
+OVERLOADABLE double8 sincos (double8 param0, __private double8 *param1);
+OVERLOADABLE double16 sincos (double16 param0, __private double16 *param1);
+OVERLOADABLE half2 sincos (half2 param0, __private half2 *param1);
+OVERLOADABLE half3 sincos (half3 param0, __private half3 *param1);
+OVERLOADABLE half4 sincos (half4 param0, __private half4 *param1);
+OVERLOADABLE half8 sincos (half8 param0, __private half8 *param1);
+OVERLOADABLE half16 sincos (half16 param0, __private half16 *param1);
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_math_20.h b/drivers/pocl-gen7/lib/beignet/include/ocl_math_20.h
new file mode 100644
index 0000000..1e183eb
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_math_20.h
@@ -0,0 +1,202 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_MATH_20_H__
+#define __OCL_MATH_20_H__
+
+#include "ocl_types.h"
+#include "ocl_math_common.h"
+
+OVERLOADABLE float lgamma_r(float x, int *signgamp);
+OVERLOADABLE float sincos(float x, float *cosval);
+OVERLOADABLE float modf(float x, float *i);
+OVERLOADABLE float frexp(float x, int *exp);
+OVERLOADABLE float fract(float x, float *p);
+OVERLOADABLE float remquo(float x, float y, int *quo);
+
+OVERLOADABLE half lgamma_r(half x, int *signgamp);
+OVERLOADABLE half sincos(half x, half *cosval);
+OVERLOADABLE half frexp(half x, int *exp);
+OVERLOADABLE half modf(half x, half *i);
+OVERLOADABLE half fract(half x, half *p);
+OVERLOADABLE half remquo(half x, half y, int *quo);
+
+//------- double -----------
+OVERLOADABLE double fract(double x, double *p);
+OVERLOADABLE double frexp(double x, int *exp);
+OVERLOADABLE double lgamma_r(double x, int *signgamp);
+OVERLOADABLE double modf(double x, double *i);
+OVERLOADABLE double remquo(double x, double y, int *quo);
+OVERLOADABLE double sincos(double x, double *cosval);
+
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//math builtin functions
+//gentype fract (gentype x, __generic gentype *iptr)
+
+OVERLOADABLE float2 fract (float2 param0, __generic float2 *param1);
+OVERLOADABLE float3 fract (float3 param0, __generic float3 *param1);
+OVERLOADABLE float4 fract (float4 param0, __generic float4 *param1);
+OVERLOADABLE float8 fract (float8 param0, __generic float8 *param1);
+OVERLOADABLE float16 fract (float16 param0, __generic float16 *param1);
+OVERLOADABLE double2 fract (double2 param0, __generic double2 *param1);
+OVERLOADABLE double3 fract (double3 param0, __generic double3 *param1);
+OVERLOADABLE double4 fract (double4 param0, __generic double4 *param1);
+OVERLOADABLE double8 fract (double8 param0, __generic double8 *param1);
+OVERLOADABLE double16 fract (double16 param0, __generic double16 *param1);
+OVERLOADABLE half2 fract (half2 param0, __generic half2 *param1);
+OVERLOADABLE half3 fract (half3 param0, __generic half3 *param1);
+OVERLOADABLE half4 fract (half4 param0, __generic half4 *param1);
+OVERLOADABLE half8 fract (half8 param0, __generic half8 *param1);
+OVERLOADABLE half16 fract (half16 param0, __generic half16 *param1);
+
+//floatn frexp (floatn x, __generic intn *exp)
+
+OVERLOADABLE float2 frexp (float2 param0, __generic int2 *param1);
+OVERLOADABLE float3 frexp (float3 param0, __generic int3 *param1);
+OVERLOADABLE float4 frexp (float4 param0, __generic int4 *param1);
+OVERLOADABLE float8 frexp (float8 param0, __generic int8 *param1);
+OVERLOADABLE float16 frexp (float16 param0, __generic int16 *param1);
+
+//float frexp (float x, __generic int *exp)
+
+
+//halfn frexp (halfn x, __generic intn *exp)
+
+OVERLOADABLE half2 frexp (half2 param0, __generic int2 *param1);
+OVERLOADABLE half3 frexp (half3 param0, __generic int3 *param1);
+OVERLOADABLE half4 frexp (half4 param0, __generic int4 *param1);
+OVERLOADABLE half8 frexp (half8 param0, __generic int8 *param1);
+OVERLOADABLE half16 frexp (half16 param0, __generic int16 *param1);
+
+//half frexp (half x, __generic int *exp)
+
+
+//doublen frexp (doublen x, __generic intn *exp)
+
+OVERLOADABLE double2 frexp (double2 param0, __generic int2 *param1);
+OVERLOADABLE double3 frexp (double3 param0, __generic int3 *param1);
+OVERLOADABLE double4 frexp (double4 param0, __generic int4 *param1);
+OVERLOADABLE double8 frexp (double8 param0, __generic int8 *param1);
+OVERLOADABLE double16 frexp (double16 param0, __generic int16 *param1);
+
+//double frexp (double x, __generic int *exp)
+
+
+//floatn lgamma_r (floatn x, __generic intn *signp)
+
+OVERLOADABLE float2 lgamma_r (float2 param0, __generic int2 *param1);
+OVERLOADABLE float3 lgamma_r (float3 param0, __generic int3 *param1);
+OVERLOADABLE float4 lgamma_r (float4 param0, __generic int4 *param1);
+OVERLOADABLE float8 lgamma_r (float8 param0, __generic int8 *param1);
+OVERLOADABLE float16 lgamma_r (float16 param0, __generic int16 *param1);
+
+//float lgamma_r (float x, __generic int *signp)
+
+
+//halfn lgamma_r (halfn x, __generic intn *signp)
+
+OVERLOADABLE half2 lgamma_r (half2 param0, __generic int2 *param1);
+OVERLOADABLE half3 lgamma_r (half3 param0, __generic int3 *param1);
+OVERLOADABLE half4 lgamma_r (half4 param0, __generic int4 *param1);
+OVERLOADABLE half8 lgamma_r (half8 param0, __generic int8 *param1);
+OVERLOADABLE half16 lgamma_r (half16 param0, __generic int16 *param1);
+
+//half lgamma_r (half x, __generic int *signp)
+
+
+//doublen lgamma_r (doublen x, __generic intn *signp)
+
+OVERLOADABLE double2 lgamma_r (double2 param0, __generic int2 *param1);
+OVERLOADABLE double3 lgamma_r (double3 param0, __generic int3 *param1);
+OVERLOADABLE double4 lgamma_r (double4 param0, __generic int4 *param1);
+OVERLOADABLE double8 lgamma_r (double8 param0, __generic int8 *param1);
+OVERLOADABLE double16 lgamma_r (double16 param0, __generic int16 *param1);
+
+//double lgamma_r (double x, __generic int *signp)
+
+
+//gentype modf (gentype x, __generic gentype *iptr)
+
+OVERLOADABLE float2 modf (float2 param0, __generic float2 *param1);
+OVERLOADABLE float3 modf (float3 param0, __generic float3 *param1);
+OVERLOADABLE float4 modf (float4 param0, __generic float4 *param1);
+OVERLOADABLE float8 modf (float8 param0, __generic float8 *param1);
+OVERLOADABLE float16 modf (float16 param0, __generic float16 *param1);
+OVERLOADABLE double2 modf (double2 param0, __generic double2 *param1);
+OVERLOADABLE double3 modf (double3 param0, __generic double3 *param1);
+OVERLOADABLE double4 modf (double4 param0, __generic double4 *param1);
+OVERLOADABLE double8 modf (double8 param0, __generic double8 *param1);
+OVERLOADABLE double16 modf (double16 param0, __generic double16 *param1);
+OVERLOADABLE half2 modf (half2 param0, __generic half2 *param1);
+OVERLOADABLE half3 modf (half3 param0, __generic half3 *param1);
+OVERLOADABLE half4 modf (half4 param0, __generic half4 *param1);
+OVERLOADABLE half8 modf (half8 param0, __generic half8 *param1);
+OVERLOADABLE half16 modf (half16 param0, __generic half16 *param1);
+
+//floatn remquo (floatn x, floatn y, __generic intn *quo)
+
+OVERLOADABLE float2 remquo (float2 param0, float2 param1, __generic int2 *param2);
+OVERLOADABLE float3 remquo (float3 param0, float3 param1, __generic int3 *param2);
+OVERLOADABLE float4 remquo (float4 param0, float4 param1, __generic int4 *param2);
+OVERLOADABLE float8 remquo (float8 param0, float8 param1, __generic int8 *param2);
+OVERLOADABLE float16 remquo (float16 param0, float16 param1, __generic int16 *param2);
+
+//float remquo (float x, float y, __generic int *quo)
+
+
+//halfn remquo (halfn x, halfn y, __generic intn *quo)
+
+OVERLOADABLE half2 remquo (half2 param0, half2 param1, __generic int2 *param2);
+OVERLOADABLE half3 remquo (half3 param0, half3 param1, __generic int3 *param2);
+OVERLOADABLE half4 remquo (half4 param0, half4 param1, __generic int4 *param2);
+OVERLOADABLE half8 remquo (half8 param0, half8 param1, __generic int8 *param2);
+OVERLOADABLE half16 remquo (half16 param0, half16 param1, __generic int16 *param2);
+
+//half remquo (half x, half y, __generic int *quo)
+
+
+//doublen remquo (doublen x, doublen y, __generic intn *quo)
+
+OVERLOADABLE double2 remquo (double2 param0, double2 param1, __generic int2 *param2);
+OVERLOADABLE double3 remquo (double3 param0, double3 param1, __generic int3 *param2);
+OVERLOADABLE double4 remquo (double4 param0, double4 param1, __generic int4 *param2);
+OVERLOADABLE double8 remquo (double8 param0, double8 param1, __generic int8 *param2);
+OVERLOADABLE double16 remquo (double16 param0, double16 param1, __generic int16 *param2);
+
+//double remquo (double x, double y, __generic int *quo)
+
+
+//gentype sincos (gentype x, __generic gentype *cosval)
+
+OVERLOADABLE float2 sincos (float2 param0, __generic float2 *param1);
+OVERLOADABLE float3 sincos (float3 param0, __generic float3 *param1);
+OVERLOADABLE float4 sincos (float4 param0, __generic float4 *param1);
+OVERLOADABLE float8 sincos (float8 param0, __generic float8 *param1);
+OVERLOADABLE float16 sincos (float16 param0, __generic float16 *param1);
+OVERLOADABLE double2 sincos (double2 param0, __generic double2 *param1);
+OVERLOADABLE double3 sincos (double3 param0, __generic double3 *param1);
+OVERLOADABLE double4 sincos (double4 param0, __generic double4 *param1);
+OVERLOADABLE double8 sincos (double8 param0, __generic double8 *param1);
+OVERLOADABLE double16 sincos (double16 param0, __generic double16 *param1);
+OVERLOADABLE half2 sincos (half2 param0, __generic half2 *param1);
+OVERLOADABLE half3 sincos (half3 param0, __generic half3 *param1);
+OVERLOADABLE half4 sincos (half4 param0, __generic half4 *param1);
+OVERLOADABLE half8 sincos (half8 param0, __generic half8 *param1);
+OVERLOADABLE half16 sincos (half16 param0, __generic half16 *param1);
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_math_common.h b/drivers/pocl-gen7/lib/beignet/include/ocl_math_common.h
new file mode 100644
index 0000000..c502891
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_math_common.h
@@ -0,0 +1,1995 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_MATH_COMMON_H__
+#define __OCL_MATH_COMMON_H__
+
+#include "ocl_types.h"
+
+OVERLOADABLE float cospi(float x);
+OVERLOADABLE float cosh(float x);
+OVERLOADABLE float acos(float x);
+OVERLOADABLE float acospi(float x);
+OVERLOADABLE float acosh(float x);
+OVERLOADABLE float sinpi(float x);
+OVERLOADABLE float sinh(float x);
+OVERLOADABLE float asin(float x);
+OVERLOADABLE float asinpi(float x);
+OVERLOADABLE float asinh(float x);
+OVERLOADABLE float tanpi(float x);
+OVERLOADABLE float tanh(float x);
+OVERLOADABLE float atan(float x);
+OVERLOADABLE float atan2(float y, float x);
+OVERLOADABLE float atan2pi(float y, float x);
+OVERLOADABLE float atanpi(float x);
+OVERLOADABLE float atanh(float x);
+OVERLOADABLE float cbrt(float x);
+OVERLOADABLE float rint(float x);
+OVERLOADABLE float copysign(float x, float y);
+OVERLOADABLE float erf(float x);
+OVERLOADABLE float erfc(float x);
+OVERLOADABLE float fmod (float x, float y);
+OVERLOADABLE float remainder(float x, float p);
+OVERLOADABLE float ldexp(float x, int n);
+OVERLOADABLE float powr(float x, float y);
+OVERLOADABLE float pow(float x, float y);
+//no pow, we use powr instead
+OVERLOADABLE float fabs(float x);
+OVERLOADABLE float trunc(float x);
+OVERLOADABLE float round(float x);
+OVERLOADABLE float floor(float x);
+OVERLOADABLE float ceil(float x);
+OVERLOADABLE float log(float x);
+OVERLOADABLE float log2(float x);
+OVERLOADABLE float log10(float x);
+OVERLOADABLE float exp(float x);
+OVERLOADABLE float exp10(float x);
+OVERLOADABLE float expm1(float x);
+OVERLOADABLE float fmin(float a, float b);
+OVERLOADABLE float fmax(float a, float b);
+OVERLOADABLE float fma(float a, float b, float c);
+OVERLOADABLE float fdim(float x, float y);
+OVERLOADABLE float maxmag(float x, float y);
+OVERLOADABLE float minmag(float x, float y);
+OVERLOADABLE float exp2(float x);
+OVERLOADABLE float mad(float a, float b, float c);
+OVERLOADABLE float sin(float x);
+OVERLOADABLE float cos(float x);
+OVERLOADABLE float tan(float x);
+OVERLOADABLE float tgamma(float x);
+OVERLOADABLE float lgamma(float x);
+
+OVERLOADABLE float log1p(float x);
+OVERLOADABLE float logb(float x);
+OVERLOADABLE int ilogb(float x);
+OVERLOADABLE float nan(uint code);
+OVERLOADABLE float sqrt(float x);
+OVERLOADABLE float rsqrt(float x);
+OVERLOADABLE float hypot(float x, float y);
+OVERLOADABLE float nextafter(float x, float y);
+OVERLOADABLE float pown(float x, int n);
+OVERLOADABLE float rootn(float x, int n);
+
+// native
+OVERLOADABLE float native_cos(float x);
+OVERLOADABLE float native_divide(float x, float y);
+OVERLOADABLE float native_exp(float x);
+OVERLOADABLE float native_exp2(float x);
+OVERLOADABLE float native_exp10(float x);
+OVERLOADABLE float native_log(float x);
+OVERLOADABLE float native_log2(float x);
+OVERLOADABLE float native_log10(float x);
+OVERLOADABLE float native_powr(float x, float y);
+OVERLOADABLE float native_recip(float x);
+OVERLOADABLE float native_rsqrt(float x);
+OVERLOADABLE float native_sin(float x);
+OVERLOADABLE float native_sqrt(float x);
+OVERLOADABLE float native_tan(float x);
+
+
+// Half float version.
+OVERLOADABLE half cospi(half x);
+OVERLOADABLE half cosh(half x);
+OVERLOADABLE half acos(half x);
+OVERLOADABLE half acospi(half x);
+OVERLOADABLE half acosh(half x);
+OVERLOADABLE half sinpi(half x);
+OVERLOADABLE half sinh(half x);
+OVERLOADABLE half asin(half x);
+OVERLOADABLE half asinpi(half x);
+OVERLOADABLE half asinh(half x);
+OVERLOADABLE half tanpi(half x);
+OVERLOADABLE half tanh(half x);
+OVERLOADABLE half atan(half x);
+OVERLOADABLE half atan2(half y, half x);
+OVERLOADABLE half atan2pi(half y, half x);
+OVERLOADABLE half atanpi(half x);
+OVERLOADABLE half atanh(half x);
+OVERLOADABLE half cbrt(half x);
+OVERLOADABLE half rint(half x);
+OVERLOADABLE half copysign(half x, half y);
+OVERLOADABLE half erf(half x);
+OVERLOADABLE half erfc(half x);
+OVERLOADABLE half fmod (half x, half y);
+OVERLOADABLE half remainder(half x, half p);
+OVERLOADABLE half ldexp(half x, int n);
+OVERLOADABLE half powr(half x, half y);
+OVERLOADABLE half pow(half x, half y);
+//no pow, we use powr instead
+OVERLOADABLE half fabs(half x);
+OVERLOADABLE half trunc(half x);
+OVERLOADABLE half round(half x);
+OVERLOADABLE half floor(half x);
+OVERLOADABLE half ceil(half x);
+OVERLOADABLE half log(half x);
+OVERLOADABLE half log2(half x);
+OVERLOADABLE half log10(half x);
+OVERLOADABLE half exp(half x);
+OVERLOADABLE half exp10(half x);
+OVERLOADABLE half expm1(half x);
+OVERLOADABLE half fmin(half a, half b);
+OVERLOADABLE half fmax(half a, half b);
+OVERLOADABLE half fma(half a, half b, half c);
+OVERLOADABLE half fdim(half x, half y);
+OVERLOADABLE half maxmag(half x, half y);
+OVERLOADABLE half minmag(half x, half y);
+OVERLOADABLE half exp2(half x);
+OVERLOADABLE half mad(half a, half b, half c);
+OVERLOADABLE half sin(half x);
+OVERLOADABLE half cos(half x);
+OVERLOADABLE half tan(half x);
+OVERLOADABLE half tgamma(half x);
+OVERLOADABLE half lgamma(half x);
+OVERLOADABLE half log1p(half x);
+OVERLOADABLE half logb(half x);
+OVERLOADABLE int ilogb(half x);
+OVERLOADABLE half nan(ushort code);
+OVERLOADABLE half pown(half x, int n);
+OVERLOADABLE half rootn(half x, int n);
+OVERLOADABLE half hypot(half x, half y);
+OVERLOADABLE half nextafter(half x, half y);
+OVERLOADABLE half sqrt(half x);
+OVERLOADABLE half rsqrt(half x);
+
+
+// native half
+OVERLOADABLE half native_cos(half x);
+OVERLOADABLE half native_divide(half x, half y);
+OVERLOADABLE half native_exp(half x);
+OVERLOADABLE half native_exp2(half x);
+OVERLOADABLE half native_exp10(half x);
+OVERLOADABLE half native_log(half x);
+OVERLOADABLE half native_log2(half x);
+OVERLOADABLE half native_log10(half x);
+OVERLOADABLE half native_powr(half x, half y);
+OVERLOADABLE half native_recip(half x);
+OVERLOADABLE half native_rsqrt(half x);
+OVERLOADABLE half native_sin(half x);
+OVERLOADABLE half native_sqrt(half x);
+OVERLOADABLE half native_tan(half x);
+
+// half accuracy
+OVERLOADABLE float half_cos(float x);
+OVERLOADABLE float half_divide(float x, float y);
+OVERLOADABLE float half_exp(float x);
+OVERLOADABLE float half_exp2(float x);
+OVERLOADABLE float half_exp10(float x);
+OVERLOADABLE float half_log(float x);
+OVERLOADABLE float half_log2(float x);
+OVERLOADABLE float half_log10(float x);
+OVERLOADABLE float half_powr(float x, float y);
+OVERLOADABLE float half_recip(float x);
+OVERLOADABLE float half_rsqrt(float x);
+OVERLOADABLE float half_sin(float x);
+OVERLOADABLE float half_sqrt(float x);
+OVERLOADABLE float half_tan(float x);
+
+
+OVERLOADABLE double acos(double x);
+OVERLOADABLE double acospi(double x);
+OVERLOADABLE double acosh(double x);
+OVERLOADABLE double asin(double x);
+OVERLOADABLE double asinpi(double x);
+OVERLOADABLE double asinh(double x);
+OVERLOADABLE double atan(double x);
+OVERLOADABLE double atan2(double x, double y);
+OVERLOADABLE double atanpi(double x);
+OVERLOADABLE double atan2pi(double x, double y);
+OVERLOADABLE double atanh(double x);
+OVERLOADABLE double exp(double x);
+OVERLOADABLE double expm1(double x);
+OVERLOADABLE double exp2(double x);
+OVERLOADABLE double exp10(double x);
+OVERLOADABLE double erf(double x);
+OVERLOADABLE double erfc(double x);
+OVERLOADABLE double cbrt(double x);
+OVERLOADABLE double ceil(double x);
+OVERLOADABLE double copysign(double x, double y);
+OVERLOADABLE double cos(double x);
+OVERLOADABLE double cosh(double x);
+OVERLOADABLE double cospi(double x);
+OVERLOADABLE double fabs(double x);
+OVERLOADABLE double fdim(double x, double y);
+OVERLOADABLE double floor(double x);
+OVERLOADABLE double fmax(double a, double b);
+OVERLOADABLE double fmin(double a, double b);
+OVERLOADABLE double fmod (double x, double y);
+OVERLOADABLE double fma(double x, double y, double z);
+OVERLOADABLE double maxmag(double x, double y);
+OVERLOADABLE double minmag(double x, double y);
+OVERLOADABLE double hypot(double x, double y);
+OVERLOADABLE double ldexp(double x, int n);
+OVERLOADABLE double log(double x);
+OVERLOADABLE double log2(double x);
+OVERLOADABLE double log10(double x);
+OVERLOADABLE double log1p(double x);
+OVERLOADABLE double logb(double x);
+OVERLOADABLE int ilogb(double x);
+OVERLOADABLE double lgamma(double x);
+OVERLOADABLE double mad(double a, double b, double c);
+OVERLOADABLE double nan(ulong code);
+OVERLOADABLE double nextafter(double x, double y);
+OVERLOADABLE double pow(double x, double y);
+OVERLOADABLE double pown(double x, int n);
+OVERLOADABLE double powr(double x, double y);
+OVERLOADABLE double remainder(double x, double p);
+OVERLOADABLE double rint(double x);
+OVERLOADABLE double round(double x);
+OVERLOADABLE double rootn(double x, int n);
+OVERLOADABLE double rsqrt(double x);
+OVERLOADABLE double sin(double x);
+OVERLOADABLE double sinh(double x);
+OVERLOADABLE double sinpi(double x);
+OVERLOADABLE double sqrt(double x);
+OVERLOADABLE double tan(double x);
+OVERLOADABLE double tanh(double x);
+OVERLOADABLE double tanpi(double x);
+OVERLOADABLE double tgamma(double x);
+OVERLOADABLE double trunc(double x);
+
+
+
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//math builtin functions
+//gentype acos (gentype)
+
+OVERLOADABLE float2 acos (float2 param0);
+OVERLOADABLE float3 acos (float3 param0);
+OVERLOADABLE float4 acos (float4 param0);
+OVERLOADABLE float8 acos (float8 param0);
+OVERLOADABLE float16 acos (float16 param0);
+OVERLOADABLE double2 acos (double2 param0);
+OVERLOADABLE double3 acos (double3 param0);
+OVERLOADABLE double4 acos (double4 param0);
+OVERLOADABLE double8 acos (double8 param0);
+OVERLOADABLE double16 acos (double16 param0);
+OVERLOADABLE half2 acos (half2 param0);
+OVERLOADABLE half3 acos (half3 param0);
+OVERLOADABLE half4 acos (half4 param0);
+OVERLOADABLE half8 acos (half8 param0);
+OVERLOADABLE half16 acos (half16 param0);
+
+//gentype acosh (gentype)
+
+OVERLOADABLE float2 acosh (float2 param0);
+OVERLOADABLE float3 acosh (float3 param0);
+OVERLOADABLE float4 acosh (float4 param0);
+OVERLOADABLE float8 acosh (float8 param0);
+OVERLOADABLE float16 acosh (float16 param0);
+OVERLOADABLE double2 acosh (double2 param0);
+OVERLOADABLE double3 acosh (double3 param0);
+OVERLOADABLE double4 acosh (double4 param0);
+OVERLOADABLE double8 acosh (double8 param0);
+OVERLOADABLE double16 acosh (double16 param0);
+OVERLOADABLE half2 acosh (half2 param0);
+OVERLOADABLE half3 acosh (half3 param0);
+OVERLOADABLE half4 acosh (half4 param0);
+OVERLOADABLE half8 acosh (half8 param0);
+OVERLOADABLE half16 acosh (half16 param0);
+
+//gentype acospi (gentype x)
+
+OVERLOADABLE float2 acospi (float2 param0);
+OVERLOADABLE float3 acospi (float3 param0);
+OVERLOADABLE float4 acospi (float4 param0);
+OVERLOADABLE float8 acospi (float8 param0);
+OVERLOADABLE float16 acospi (float16 param0);
+OVERLOADABLE double2 acospi (double2 param0);
+OVERLOADABLE double3 acospi (double3 param0);
+OVERLOADABLE double4 acospi (double4 param0);
+OVERLOADABLE double8 acospi (double8 param0);
+OVERLOADABLE double16 acospi (double16 param0);
+OVERLOADABLE half2 acospi (half2 param0);
+OVERLOADABLE half3 acospi (half3 param0);
+OVERLOADABLE half4 acospi (half4 param0);
+OVERLOADABLE half8 acospi (half8 param0);
+OVERLOADABLE half16 acospi (half16 param0);
+
+//gentype asin (gentype)
+
+OVERLOADABLE float2 asin (float2 param0);
+OVERLOADABLE float3 asin (float3 param0);
+OVERLOADABLE float4 asin (float4 param0);
+OVERLOADABLE float8 asin (float8 param0);
+OVERLOADABLE float16 asin (float16 param0);
+OVERLOADABLE double2 asin (double2 param0);
+OVERLOADABLE double3 asin (double3 param0);
+OVERLOADABLE double4 asin (double4 param0);
+OVERLOADABLE double8 asin (double8 param0);
+OVERLOADABLE double16 asin (double16 param0);
+OVERLOADABLE half2 asin (half2 param0);
+OVERLOADABLE half3 asin (half3 param0);
+OVERLOADABLE half4 asin (half4 param0);
+OVERLOADABLE half8 asin (half8 param0);
+OVERLOADABLE half16 asin (half16 param0);
+
+//gentype asinh (gentype)
+
+OVERLOADABLE float2 asinh (float2 param0);
+OVERLOADABLE float3 asinh (float3 param0);
+OVERLOADABLE float4 asinh (float4 param0);
+OVERLOADABLE float8 asinh (float8 param0);
+OVERLOADABLE float16 asinh (float16 param0);
+OVERLOADABLE double2 asinh (double2 param0);
+OVERLOADABLE double3 asinh (double3 param0);
+OVERLOADABLE double4 asinh (double4 param0);
+OVERLOADABLE double8 asinh (double8 param0);
+OVERLOADABLE double16 asinh (double16 param0);
+OVERLOADABLE half2 asinh (half2 param0);
+OVERLOADABLE half3 asinh (half3 param0);
+OVERLOADABLE half4 asinh (half4 param0);
+OVERLOADABLE half8 asinh (half8 param0);
+OVERLOADABLE half16 asinh (half16 param0);
+
+//gentype asinpi (gentype x)
+
+OVERLOADABLE float2 asinpi (float2 param0);
+OVERLOADABLE float3 asinpi (float3 param0);
+OVERLOADABLE float4 asinpi (float4 param0);
+OVERLOADABLE float8 asinpi (float8 param0);
+OVERLOADABLE float16 asinpi (float16 param0);
+OVERLOADABLE double2 asinpi (double2 param0);
+OVERLOADABLE double3 asinpi (double3 param0);
+OVERLOADABLE double4 asinpi (double4 param0);
+OVERLOADABLE double8 asinpi (double8 param0);
+OVERLOADABLE double16 asinpi (double16 param0);
+OVERLOADABLE half2 asinpi (half2 param0);
+OVERLOADABLE half3 asinpi (half3 param0);
+OVERLOADABLE half4 asinpi (half4 param0);
+OVERLOADABLE half8 asinpi (half8 param0);
+OVERLOADABLE half16 asinpi (half16 param0);
+
+//gentype atan (gentype y_over_x)
+
+OVERLOADABLE float2 atan (float2 param0);
+OVERLOADABLE float3 atan (float3 param0);
+OVERLOADABLE float4 atan (float4 param0);
+OVERLOADABLE float8 atan (float8 param0);
+OVERLOADABLE float16 atan (float16 param0);
+OVERLOADABLE double2 atan (double2 param0);
+OVERLOADABLE double3 atan (double3 param0);
+OVERLOADABLE double4 atan (double4 param0);
+OVERLOADABLE double8 atan (double8 param0);
+OVERLOADABLE double16 atan (double16 param0);
+OVERLOADABLE half2 atan (half2 param0);
+OVERLOADABLE half3 atan (half3 param0);
+OVERLOADABLE half4 atan (half4 param0);
+OVERLOADABLE half8 atan (half8 param0);
+OVERLOADABLE half16 atan (half16 param0);
+
+//gentype atan2 (gentype y, gentype x)
+
+OVERLOADABLE float2 atan2 (float2 param0, float2 param1);
+OVERLOADABLE float3 atan2 (float3 param0, float3 param1);
+OVERLOADABLE float4 atan2 (float4 param0, float4 param1);
+OVERLOADABLE float8 atan2 (float8 param0, float8 param1);
+OVERLOADABLE float16 atan2 (float16 param0, float16 param1);
+OVERLOADABLE double2 atan2 (double2 param0, double2 param1);
+OVERLOADABLE double3 atan2 (double3 param0, double3 param1);
+OVERLOADABLE double4 atan2 (double4 param0, double4 param1);
+OVERLOADABLE double8 atan2 (double8 param0, double8 param1);
+OVERLOADABLE double16 atan2 (double16 param0, double16 param1);
+OVERLOADABLE half2 atan2 (half2 param0, half2 param1);
+OVERLOADABLE half3 atan2 (half3 param0, half3 param1);
+OVERLOADABLE half4 atan2 (half4 param0, half4 param1);
+OVERLOADABLE half8 atan2 (half8 param0, half8 param1);
+OVERLOADABLE half16 atan2 (half16 param0, half16 param1);
+
+//gentype atanh (gentype)
+
+OVERLOADABLE float2 atanh (float2 param0);
+OVERLOADABLE float3 atanh (float3 param0);
+OVERLOADABLE float4 atanh (float4 param0);
+OVERLOADABLE float8 atanh (float8 param0);
+OVERLOADABLE float16 atanh (float16 param0);
+OVERLOADABLE double2 atanh (double2 param0);
+OVERLOADABLE double3 atanh (double3 param0);
+OVERLOADABLE double4 atanh (double4 param0);
+OVERLOADABLE double8 atanh (double8 param0);
+OVERLOADABLE double16 atanh (double16 param0);
+OVERLOADABLE half2 atanh (half2 param0);
+OVERLOADABLE half3 atanh (half3 param0);
+OVERLOADABLE half4 atanh (half4 param0);
+OVERLOADABLE half8 atanh (half8 param0);
+OVERLOADABLE half16 atanh (half16 param0);
+
+//gentype atanpi (gentype x)
+
+OVERLOADABLE float2 atanpi (float2 param0);
+OVERLOADABLE float3 atanpi (float3 param0);
+OVERLOADABLE float4 atanpi (float4 param0);
+OVERLOADABLE float8 atanpi (float8 param0);
+OVERLOADABLE float16 atanpi (float16 param0);
+OVERLOADABLE double2 atanpi (double2 param0);
+OVERLOADABLE double3 atanpi (double3 param0);
+OVERLOADABLE double4 atanpi (double4 param0);
+OVERLOADABLE double8 atanpi (double8 param0);
+OVERLOADABLE double16 atanpi (double16 param0);
+OVERLOADABLE half2 atanpi (half2 param0);
+OVERLOADABLE half3 atanpi (half3 param0);
+OVERLOADABLE half4 atanpi (half4 param0);
+OVERLOADABLE half8 atanpi (half8 param0);
+OVERLOADABLE half16 atanpi (half16 param0);
+
+//gentype atan2pi (gentype y, gentype x)
+
+OVERLOADABLE float2 atan2pi (float2 param0, float2 param1);
+OVERLOADABLE float3 atan2pi (float3 param0, float3 param1);
+OVERLOADABLE float4 atan2pi (float4 param0, float4 param1);
+OVERLOADABLE float8 atan2pi (float8 param0, float8 param1);
+OVERLOADABLE float16 atan2pi (float16 param0, float16 param1);
+OVERLOADABLE double2 atan2pi (double2 param0, double2 param1);
+OVERLOADABLE double3 atan2pi (double3 param0, double3 param1);
+OVERLOADABLE double4 atan2pi (double4 param0, double4 param1);
+OVERLOADABLE double8 atan2pi (double8 param0, double8 param1);
+OVERLOADABLE double16 atan2pi (double16 param0, double16 param1);
+OVERLOADABLE half2 atan2pi (half2 param0, half2 param1);
+OVERLOADABLE half3 atan2pi (half3 param0, half3 param1);
+OVERLOADABLE half4 atan2pi (half4 param0, half4 param1);
+OVERLOADABLE half8 atan2pi (half8 param0, half8 param1);
+OVERLOADABLE half16 atan2pi (half16 param0, half16 param1);
+
+//gentype cbrt (gentype)
+
+OVERLOADABLE float2 cbrt (float2 param0);
+OVERLOADABLE float3 cbrt (float3 param0);
+OVERLOADABLE float4 cbrt (float4 param0);
+OVERLOADABLE float8 cbrt (float8 param0);
+OVERLOADABLE float16 cbrt (float16 param0);
+OVERLOADABLE double2 cbrt (double2 param0);
+OVERLOADABLE double3 cbrt (double3 param0);
+OVERLOADABLE double4 cbrt (double4 param0);
+OVERLOADABLE double8 cbrt (double8 param0);
+OVERLOADABLE double16 cbrt (double16 param0);
+OVERLOADABLE half2 cbrt (half2 param0);
+OVERLOADABLE half3 cbrt (half3 param0);
+OVERLOADABLE half4 cbrt (half4 param0);
+OVERLOADABLE half8 cbrt (half8 param0);
+OVERLOADABLE half16 cbrt (half16 param0);
+
+//gentype ceil (gentype)
+
+OVERLOADABLE float2 ceil (float2 param0);
+OVERLOADABLE float3 ceil (float3 param0);
+OVERLOADABLE float4 ceil (float4 param0);
+OVERLOADABLE float8 ceil (float8 param0);
+OVERLOADABLE float16 ceil (float16 param0);
+OVERLOADABLE double2 ceil (double2 param0);
+OVERLOADABLE double3 ceil (double3 param0);
+OVERLOADABLE double4 ceil (double4 param0);
+OVERLOADABLE double8 ceil (double8 param0);
+OVERLOADABLE double16 ceil (double16 param0);
+OVERLOADABLE half2 ceil (half2 param0);
+OVERLOADABLE half3 ceil (half3 param0);
+OVERLOADABLE half4 ceil (half4 param0);
+OVERLOADABLE half8 ceil (half8 param0);
+OVERLOADABLE half16 ceil (half16 param0);
+
+//gentype copysign (gentype x, gentype y)
+
+OVERLOADABLE float2 copysign (float2 param0, float2 param1);
+OVERLOADABLE float3 copysign (float3 param0, float3 param1);
+OVERLOADABLE float4 copysign (float4 param0, float4 param1);
+OVERLOADABLE float8 copysign (float8 param0, float8 param1);
+OVERLOADABLE float16 copysign (float16 param0, float16 param1);
+OVERLOADABLE double2 copysign (double2 param0, double2 param1);
+OVERLOADABLE double3 copysign (double3 param0, double3 param1);
+OVERLOADABLE double4 copysign (double4 param0, double4 param1);
+OVERLOADABLE double8 copysign (double8 param0, double8 param1);
+OVERLOADABLE double16 copysign (double16 param0, double16 param1);
+OVERLOADABLE half2 copysign (half2 param0, half2 param1);
+OVERLOADABLE half3 copysign (half3 param0, half3 param1);
+OVERLOADABLE half4 copysign (half4 param0, half4 param1);
+OVERLOADABLE half8 copysign (half8 param0, half8 param1);
+OVERLOADABLE half16 copysign (half16 param0, half16 param1);
+
+//gentype cos (gentype)
+
+OVERLOADABLE float2 cos (float2 param0);
+OVERLOADABLE float3 cos (float3 param0);
+OVERLOADABLE float4 cos (float4 param0);
+OVERLOADABLE float8 cos (float8 param0);
+OVERLOADABLE float16 cos (float16 param0);
+OVERLOADABLE double2 cos (double2 param0);
+OVERLOADABLE double3 cos (double3 param0);
+OVERLOADABLE double4 cos (double4 param0);
+OVERLOADABLE double8 cos (double8 param0);
+OVERLOADABLE double16 cos (double16 param0);
+OVERLOADABLE half2 cos (half2 param0);
+OVERLOADABLE half3 cos (half3 param0);
+OVERLOADABLE half4 cos (half4 param0);
+OVERLOADABLE half8 cos (half8 param0);
+OVERLOADABLE half16 cos (half16 param0);
+
+//gentype cosh (gentype)
+
+OVERLOADABLE float2 cosh (float2 param0);
+OVERLOADABLE float3 cosh (float3 param0);
+OVERLOADABLE float4 cosh (float4 param0);
+OVERLOADABLE float8 cosh (float8 param0);
+OVERLOADABLE float16 cosh (float16 param0);
+OVERLOADABLE double2 cosh (double2 param0);
+OVERLOADABLE double3 cosh (double3 param0);
+OVERLOADABLE double4 cosh (double4 param0);
+OVERLOADABLE double8 cosh (double8 param0);
+OVERLOADABLE double16 cosh (double16 param0);
+OVERLOADABLE half2 cosh (half2 param0);
+OVERLOADABLE half3 cosh (half3 param0);
+OVERLOADABLE half4 cosh (half4 param0);
+OVERLOADABLE half8 cosh (half8 param0);
+OVERLOADABLE half16 cosh (half16 param0);
+
+//gentype cospi (gentype x)
+
+OVERLOADABLE float2 cospi (float2 param0);
+OVERLOADABLE float3 cospi (float3 param0);
+OVERLOADABLE float4 cospi (float4 param0);
+OVERLOADABLE float8 cospi (float8 param0);
+OVERLOADABLE float16 cospi (float16 param0);
+OVERLOADABLE double2 cospi (double2 param0);
+OVERLOADABLE double3 cospi (double3 param0);
+OVERLOADABLE double4 cospi (double4 param0);
+OVERLOADABLE double8 cospi (double8 param0);
+OVERLOADABLE double16 cospi (double16 param0);
+OVERLOADABLE half2 cospi (half2 param0);
+OVERLOADABLE half3 cospi (half3 param0);
+OVERLOADABLE half4 cospi (half4 param0);
+OVERLOADABLE half8 cospi (half8 param0);
+OVERLOADABLE half16 cospi (half16 param0);
+
+//gentype erfc (gentype)
+
+OVERLOADABLE float2 erfc (float2 param0);
+OVERLOADABLE float3 erfc (float3 param0);
+OVERLOADABLE float4 erfc (float4 param0);
+OVERLOADABLE float8 erfc (float8 param0);
+OVERLOADABLE float16 erfc (float16 param0);
+OVERLOADABLE double2 erfc (double2 param0);
+OVERLOADABLE double3 erfc (double3 param0);
+OVERLOADABLE double4 erfc (double4 param0);
+OVERLOADABLE double8 erfc (double8 param0);
+OVERLOADABLE double16 erfc (double16 param0);
+OVERLOADABLE half2 erfc (half2 param0);
+OVERLOADABLE half3 erfc (half3 param0);
+OVERLOADABLE half4 erfc (half4 param0);
+OVERLOADABLE half8 erfc (half8 param0);
+OVERLOADABLE half16 erfc (half16 param0);
+
+//gentype erf (gentype)
+
+OVERLOADABLE float2 erf (float2 param0);
+OVERLOADABLE float3 erf (float3 param0);
+OVERLOADABLE float4 erf (float4 param0);
+OVERLOADABLE float8 erf (float8 param0);
+OVERLOADABLE float16 erf (float16 param0);
+OVERLOADABLE double2 erf (double2 param0);
+OVERLOADABLE double3 erf (double3 param0);
+OVERLOADABLE double4 erf (double4 param0);
+OVERLOADABLE double8 erf (double8 param0);
+OVERLOADABLE double16 erf (double16 param0);
+OVERLOADABLE half2 erf (half2 param0);
+OVERLOADABLE half3 erf (half3 param0);
+OVERLOADABLE half4 erf (half4 param0);
+OVERLOADABLE half8 erf (half8 param0);
+OVERLOADABLE half16 erf (half16 param0);
+
+//gentype exp (gentype x)
+
+OVERLOADABLE float2 exp (float2 param0);
+OVERLOADABLE float3 exp (float3 param0);
+OVERLOADABLE float4 exp (float4 param0);
+OVERLOADABLE float8 exp (float8 param0);
+OVERLOADABLE float16 exp (float16 param0);
+OVERLOADABLE double2 exp (double2 param0);
+OVERLOADABLE double3 exp (double3 param0);
+OVERLOADABLE double4 exp (double4 param0);
+OVERLOADABLE double8 exp (double8 param0);
+OVERLOADABLE double16 exp (double16 param0);
+OVERLOADABLE half2 exp (half2 param0);
+OVERLOADABLE half3 exp (half3 param0);
+OVERLOADABLE half4 exp (half4 param0);
+OVERLOADABLE half8 exp (half8 param0);
+OVERLOADABLE half16 exp (half16 param0);
+
+//gentype exp2 (gentype)
+
+OVERLOADABLE float2 exp2 (float2 param0);
+OVERLOADABLE float3 exp2 (float3 param0);
+OVERLOADABLE float4 exp2 (float4 param0);
+OVERLOADABLE float8 exp2 (float8 param0);
+OVERLOADABLE float16 exp2 (float16 param0);
+OVERLOADABLE double2 exp2 (double2 param0);
+OVERLOADABLE double3 exp2 (double3 param0);
+OVERLOADABLE double4 exp2 (double4 param0);
+OVERLOADABLE double8 exp2 (double8 param0);
+OVERLOADABLE double16 exp2 (double16 param0);
+OVERLOADABLE half2 exp2 (half2 param0);
+OVERLOADABLE half3 exp2 (half3 param0);
+OVERLOADABLE half4 exp2 (half4 param0);
+OVERLOADABLE half8 exp2 (half8 param0);
+OVERLOADABLE half16 exp2 (half16 param0);
+
+//gentype exp10 (gentype)
+
+OVERLOADABLE float2 exp10 (float2 param0);
+OVERLOADABLE float3 exp10 (float3 param0);
+OVERLOADABLE float4 exp10 (float4 param0);
+OVERLOADABLE float8 exp10 (float8 param0);
+OVERLOADABLE float16 exp10 (float16 param0);
+OVERLOADABLE double2 exp10 (double2 param0);
+OVERLOADABLE double3 exp10 (double3 param0);
+OVERLOADABLE double4 exp10 (double4 param0);
+OVERLOADABLE double8 exp10 (double8 param0);
+OVERLOADABLE double16 exp10 (double16 param0);
+OVERLOADABLE half2 exp10 (half2 param0);
+OVERLOADABLE half3 exp10 (half3 param0);
+OVERLOADABLE half4 exp10 (half4 param0);
+OVERLOADABLE half8 exp10 (half8 param0);
+OVERLOADABLE half16 exp10 (half16 param0);
+
+//gentype expm1 (gentype x)
+
+OVERLOADABLE float2 expm1 (float2 param0);
+OVERLOADABLE float3 expm1 (float3 param0);
+OVERLOADABLE float4 expm1 (float4 param0);
+OVERLOADABLE float8 expm1 (float8 param0);
+OVERLOADABLE float16 expm1 (float16 param0);
+OVERLOADABLE double2 expm1 (double2 param0);
+OVERLOADABLE double3 expm1 (double3 param0);
+OVERLOADABLE double4 expm1 (double4 param0);
+OVERLOADABLE double8 expm1 (double8 param0);
+OVERLOADABLE double16 expm1 (double16 param0);
+OVERLOADABLE half2 expm1 (half2 param0);
+OVERLOADABLE half3 expm1 (half3 param0);
+OVERLOADABLE half4 expm1 (half4 param0);
+OVERLOADABLE half8 expm1 (half8 param0);
+OVERLOADABLE half16 expm1 (half16 param0);
+
+//gentype fabs (gentype)
+
+OVERLOADABLE float2 fabs (float2 param0);
+OVERLOADABLE float3 fabs (float3 param0);
+OVERLOADABLE float4 fabs (float4 param0);
+OVERLOADABLE float8 fabs (float8 param0);
+OVERLOADABLE float16 fabs (float16 param0);
+OVERLOADABLE double2 fabs (double2 param0);
+OVERLOADABLE double3 fabs (double3 param0);
+OVERLOADABLE double4 fabs (double4 param0);
+OVERLOADABLE double8 fabs (double8 param0);
+OVERLOADABLE double16 fabs (double16 param0);
+OVERLOADABLE half2 fabs (half2 param0);
+OVERLOADABLE half3 fabs (half3 param0);
+OVERLOADABLE half4 fabs (half4 param0);
+OVERLOADABLE half8 fabs (half8 param0);
+OVERLOADABLE half16 fabs (half16 param0);
+
+//gentype fdim (gentype x, gentype y)
+
+OVERLOADABLE float2 fdim (float2 param0, float2 param1);
+OVERLOADABLE float3 fdim (float3 param0, float3 param1);
+OVERLOADABLE float4 fdim (float4 param0, float4 param1);
+OVERLOADABLE float8 fdim (float8 param0, float8 param1);
+OVERLOADABLE float16 fdim (float16 param0, float16 param1);
+OVERLOADABLE double2 fdim (double2 param0, double2 param1);
+OVERLOADABLE double3 fdim (double3 param0, double3 param1);
+OVERLOADABLE double4 fdim (double4 param0, double4 param1);
+OVERLOADABLE double8 fdim (double8 param0, double8 param1);
+OVERLOADABLE double16 fdim (double16 param0, double16 param1);
+OVERLOADABLE half2 fdim (half2 param0, half2 param1);
+OVERLOADABLE half3 fdim (half3 param0, half3 param1);
+OVERLOADABLE half4 fdim (half4 param0, half4 param1);
+OVERLOADABLE half8 fdim (half8 param0, half8 param1);
+OVERLOADABLE half16 fdim (half16 param0, half16 param1);
+
+//gentype floor (gentype)
+
+OVERLOADABLE float2 floor (float2 param0);
+OVERLOADABLE float3 floor (float3 param0);
+OVERLOADABLE float4 floor (float4 param0);
+OVERLOADABLE float8 floor (float8 param0);
+OVERLOADABLE float16 floor (float16 param0);
+OVERLOADABLE double2 floor (double2 param0);
+OVERLOADABLE double3 floor (double3 param0);
+OVERLOADABLE double4 floor (double4 param0);
+OVERLOADABLE double8 floor (double8 param0);
+OVERLOADABLE double16 floor (double16 param0);
+OVERLOADABLE half2 floor (half2 param0);
+OVERLOADABLE half3 floor (half3 param0);
+OVERLOADABLE half4 floor (half4 param0);
+OVERLOADABLE half8 floor (half8 param0);
+OVERLOADABLE half16 floor (half16 param0);
+
+//gentype fma (gentype a, gentype b, gentype c)
+
+OVERLOADABLE float2 fma (float2 param0, float2 param1, float2 param2);
+OVERLOADABLE float3 fma (float3 param0, float3 param1, float3 param2);
+OVERLOADABLE float4 fma (float4 param0, float4 param1, float4 param2);
+OVERLOADABLE float8 fma (float8 param0, float8 param1, float8 param2);
+OVERLOADABLE float16 fma (float16 param0, float16 param1, float16 param2);
+OVERLOADABLE double2 fma (double2 param0, double2 param1, double2 param2);
+OVERLOADABLE double3 fma (double3 param0, double3 param1, double3 param2);
+OVERLOADABLE double4 fma (double4 param0, double4 param1, double4 param2);
+OVERLOADABLE double8 fma (double8 param0, double8 param1, double8 param2);
+OVERLOADABLE double16 fma (double16 param0, double16 param1, double16 param2);
+OVERLOADABLE half2 fma (half2 param0, half2 param1, half2 param2);
+OVERLOADABLE half3 fma (half3 param0, half3 param1, half3 param2);
+OVERLOADABLE half4 fma (half4 param0, half4 param1, half4 param2);
+OVERLOADABLE half8 fma (half8 param0, half8 param1, half8 param2);
+OVERLOADABLE half16 fma (half16 param0, half16 param1, half16 param2);
+
+//gentype fmax (gentype x, gentype y)
+
+OVERLOADABLE float2 fmax (float2 param0, float2 param1);
+OVERLOADABLE float3 fmax (float3 param0, float3 param1);
+OVERLOADABLE float4 fmax (float4 param0, float4 param1);
+OVERLOADABLE float8 fmax (float8 param0, float8 param1);
+OVERLOADABLE float16 fmax (float16 param0, float16 param1);
+OVERLOADABLE double2 fmax (double2 param0, double2 param1);
+OVERLOADABLE double3 fmax (double3 param0, double3 param1);
+OVERLOADABLE double4 fmax (double4 param0, double4 param1);
+OVERLOADABLE double8 fmax (double8 param0, double8 param1);
+OVERLOADABLE double16 fmax (double16 param0, double16 param1);
+OVERLOADABLE half2 fmax (half2 param0, half2 param1);
+OVERLOADABLE half3 fmax (half3 param0, half3 param1);
+OVERLOADABLE half4 fmax (half4 param0, half4 param1);
+OVERLOADABLE half8 fmax (half8 param0, half8 param1);
+OVERLOADABLE half16 fmax (half16 param0, half16 param1);
+
+//gentypef fmax (gentypef x, float y)
+
+OVERLOADABLE float2 fmax (float2 param0, float param1);
+OVERLOADABLE float3 fmax (float3 param0, float param1);
+OVERLOADABLE float4 fmax (float4 param0, float param1);
+OVERLOADABLE float8 fmax (float8 param0, float param1);
+OVERLOADABLE float16 fmax (float16 param0, float param1);
+
+//gentypeh fmax (gentypeh x, half y)
+
+OVERLOADABLE half2 fmax (half2 param0, half param1);
+OVERLOADABLE half3 fmax (half3 param0, half param1);
+OVERLOADABLE half4 fmax (half4 param0, half param1);
+OVERLOADABLE half8 fmax (half8 param0, half param1);
+OVERLOADABLE half16 fmax (half16 param0, half param1);
+
+//gentyped fmax (gentyped x, double y)
+
+OVERLOADABLE double2 fmax (double2 param0, double param1);
+OVERLOADABLE double3 fmax (double3 param0, double param1);
+OVERLOADABLE double4 fmax (double4 param0, double param1);
+OVERLOADABLE double8 fmax (double8 param0, double param1);
+OVERLOADABLE double16 fmax (double16 param0, double param1);
+
+//gentype fmin (gentype x, gentype y)
+
+OVERLOADABLE float2 fmin (float2 param0, float2 param1);
+OVERLOADABLE float3 fmin (float3 param0, float3 param1);
+OVERLOADABLE float4 fmin (float4 param0, float4 param1);
+OVERLOADABLE float8 fmin (float8 param0, float8 param1);
+OVERLOADABLE float16 fmin (float16 param0, float16 param1);
+OVERLOADABLE double2 fmin (double2 param0, double2 param1);
+OVERLOADABLE double3 fmin (double3 param0, double3 param1);
+OVERLOADABLE double4 fmin (double4 param0, double4 param1);
+OVERLOADABLE double8 fmin (double8 param0, double8 param1);
+OVERLOADABLE double16 fmin (double16 param0, double16 param1);
+OVERLOADABLE half2 fmin (half2 param0, half2 param1);
+OVERLOADABLE half3 fmin (half3 param0, half3 param1);
+OVERLOADABLE half4 fmin (half4 param0, half4 param1);
+OVERLOADABLE half8 fmin (half8 param0, half8 param1);
+OVERLOADABLE half16 fmin (half16 param0, half16 param1);
+
+//gentypef fmin (gentypef x, float y)
+
+OVERLOADABLE float2 fmin (float2 param0, float param1);
+OVERLOADABLE float3 fmin (float3 param0, float param1);
+OVERLOADABLE float4 fmin (float4 param0, float param1);
+OVERLOADABLE float8 fmin (float8 param0, float param1);
+OVERLOADABLE float16 fmin (float16 param0, float param1);
+
+//gentypeh fmin (gentypeh x, half y)
+
+OVERLOADABLE half2 fmin (half2 param0, half param1);
+OVERLOADABLE half3 fmin (half3 param0, half param1);
+OVERLOADABLE half4 fmin (half4 param0, half param1);
+OVERLOADABLE half8 fmin (half8 param0, half param1);
+OVERLOADABLE half16 fmin (half16 param0, half param1);
+
+//gentyped fmin (gentyped x, double y)
+
+OVERLOADABLE double2 fmin (double2 param0, double param1);
+OVERLOADABLE double3 fmin (double3 param0, double param1);
+OVERLOADABLE double4 fmin (double4 param0, double param1);
+OVERLOADABLE double8 fmin (double8 param0, double param1);
+OVERLOADABLE double16 fmin (double16 param0, double param1);
+
+//gentype fmod (gentype x, gentype y)
+
+OVERLOADABLE float2 fmod (float2 param0, float2 param1);
+OVERLOADABLE float3 fmod (float3 param0, float3 param1);
+OVERLOADABLE float4 fmod (float4 param0, float4 param1);
+OVERLOADABLE float8 fmod (float8 param0, float8 param1);
+OVERLOADABLE float16 fmod (float16 param0, float16 param1);
+OVERLOADABLE double2 fmod (double2 param0, double2 param1);
+OVERLOADABLE double3 fmod (double3 param0, double3 param1);
+OVERLOADABLE double4 fmod (double4 param0, double4 param1);
+OVERLOADABLE double8 fmod (double8 param0, double8 param1);
+OVERLOADABLE double16 fmod (double16 param0, double16 param1);
+OVERLOADABLE half2 fmod (half2 param0, half2 param1);
+OVERLOADABLE half3 fmod (half3 param0, half3 param1);
+OVERLOADABLE half4 fmod (half4 param0, half4 param1);
+OVERLOADABLE half8 fmod (half8 param0, half8 param1);
+OVERLOADABLE half16 fmod (half16 param0, half16 param1);
+
+//gentype hypot (gentype x, gentype y)
+
+OVERLOADABLE float2 hypot (float2 param0, float2 param1);
+OVERLOADABLE float3 hypot (float3 param0, float3 param1);
+OVERLOADABLE float4 hypot (float4 param0, float4 param1);
+OVERLOADABLE float8 hypot (float8 param0, float8 param1);
+OVERLOADABLE float16 hypot (float16 param0, float16 param1);
+OVERLOADABLE double2 hypot (double2 param0, double2 param1);
+OVERLOADABLE double3 hypot (double3 param0, double3 param1);
+OVERLOADABLE double4 hypot (double4 param0, double4 param1);
+OVERLOADABLE double8 hypot (double8 param0, double8 param1);
+OVERLOADABLE double16 hypot (double16 param0, double16 param1);
+OVERLOADABLE half2 hypot (half2 param0, half2 param1);
+OVERLOADABLE half3 hypot (half3 param0, half3 param1);
+OVERLOADABLE half4 hypot (half4 param0, half4 param1);
+OVERLOADABLE half8 hypot (half8 param0, half8 param1);
+OVERLOADABLE half16 hypot (half16 param0, half16 param1);
+
+//intn ilogb (floatn x)
+
+OVERLOADABLE int2 ilogb (float2 param0);
+OVERLOADABLE int3 ilogb (float3 param0);
+OVERLOADABLE int4 ilogb (float4 param0);
+OVERLOADABLE int8 ilogb (float8 param0);
+OVERLOADABLE int16 ilogb (float16 param0);
+
+//int ilogb (float x)
+
+
+//shortn ilogb (halfn x)
+
+OVERLOADABLE short2 ilogb (half2 param0);
+OVERLOADABLE short3 ilogb (half3 param0);
+OVERLOADABLE short4 ilogb (half4 param0);
+OVERLOADABLE short8 ilogb (half8 param0);
+OVERLOADABLE short16 ilogb (half16 param0);
+
+//short ilogb (half x)
+
+
+//int ilogb (double x)
+
+
+//floatn ldexp (floatn x, intn k)
+
+OVERLOADABLE float2 ldexp (float2 param0, int2 param1);
+OVERLOADABLE float3 ldexp (float3 param0, int3 param1);
+OVERLOADABLE float4 ldexp (float4 param0, int4 param1);
+OVERLOADABLE float8 ldexp (float8 param0, int8 param1);
+OVERLOADABLE float16 ldexp (float16 param0, int16 param1);
+
+//floatn ldexp (floatn x, int k)
+
+OVERLOADABLE float2 ldexp (float2 param0, int param1);
+OVERLOADABLE float3 ldexp (float3 param0, int param1);
+OVERLOADABLE float4 ldexp (float4 param0, int param1);
+OVERLOADABLE float8 ldexp (float8 param0, int param1);
+OVERLOADABLE float16 ldexp (float16 param0, int param1);
+
+//float ldexp (float x, int k)
+
+
+//halfn ldexp (halfn x, intn k)
+
+OVERLOADABLE half2 ldexp (half2 param0, int2 param1);
+OVERLOADABLE half3 ldexp (half3 param0, int3 param1);
+OVERLOADABLE half4 ldexp (half4 param0, int4 param1);
+OVERLOADABLE half8 ldexp (half8 param0, int8 param1);
+OVERLOADABLE half16 ldexp (half16 param0, int16 param1);
+
+//halfn ldexp (halfn x, int k)
+
+OVERLOADABLE half2 ldexp (half2 param0, int param1);
+OVERLOADABLE half3 ldexp (half3 param0, int param1);
+OVERLOADABLE half4 ldexp (half4 param0, int param1);
+OVERLOADABLE half8 ldexp (half8 param0, int param1);
+OVERLOADABLE half16 ldexp (half16 param0, int param1);
+
+//half ldexp (half x, int k)
+
+
+//double ldexp (double x, int k)
+
+
+//gentype lgamma (gentype x)
+
+OVERLOADABLE float2 lgamma (float2 param0);
+OVERLOADABLE float3 lgamma (float3 param0);
+OVERLOADABLE float4 lgamma (float4 param0);
+OVERLOADABLE float8 lgamma (float8 param0);
+OVERLOADABLE float16 lgamma (float16 param0);
+OVERLOADABLE double2 lgamma (double2 param0);
+OVERLOADABLE double3 lgamma (double3 param0);
+OVERLOADABLE double4 lgamma (double4 param0);
+OVERLOADABLE double8 lgamma (double8 param0);
+OVERLOADABLE double16 lgamma (double16 param0);
+OVERLOADABLE half2 lgamma (half2 param0);
+OVERLOADABLE half3 lgamma (half3 param0);
+OVERLOADABLE half4 lgamma (half4 param0);
+OVERLOADABLE half8 lgamma (half8 param0);
+OVERLOADABLE half16 lgamma (half16 param0);
+
+//gentype log (gentype)
+
+OVERLOADABLE float2 log (float2 param0);
+OVERLOADABLE float3 log (float3 param0);
+OVERLOADABLE float4 log (float4 param0);
+OVERLOADABLE float8 log (float8 param0);
+OVERLOADABLE float16 log (float16 param0);
+OVERLOADABLE double2 log (double2 param0);
+OVERLOADABLE double3 log (double3 param0);
+OVERLOADABLE double4 log (double4 param0);
+OVERLOADABLE double8 log (double8 param0);
+OVERLOADABLE double16 log (double16 param0);
+OVERLOADABLE half2 log (half2 param0);
+OVERLOADABLE half3 log (half3 param0);
+OVERLOADABLE half4 log (half4 param0);
+OVERLOADABLE half8 log (half8 param0);
+OVERLOADABLE half16 log (half16 param0);
+
+//gentype log2 (gentype)
+
+OVERLOADABLE float2 log2 (float2 param0);
+OVERLOADABLE float3 log2 (float3 param0);
+OVERLOADABLE float4 log2 (float4 param0);
+OVERLOADABLE float8 log2 (float8 param0);
+OVERLOADABLE float16 log2 (float16 param0);
+OVERLOADABLE double2 log2 (double2 param0);
+OVERLOADABLE double3 log2 (double3 param0);
+OVERLOADABLE double4 log2 (double4 param0);
+OVERLOADABLE double8 log2 (double8 param0);
+OVERLOADABLE double16 log2 (double16 param0);
+OVERLOADABLE half2 log2 (half2 param0);
+OVERLOADABLE half3 log2 (half3 param0);
+OVERLOADABLE half4 log2 (half4 param0);
+OVERLOADABLE half8 log2 (half8 param0);
+OVERLOADABLE half16 log2 (half16 param0);
+
+//gentype log10 (gentype)
+
+OVERLOADABLE float2 log10 (float2 param0);
+OVERLOADABLE float3 log10 (float3 param0);
+OVERLOADABLE float4 log10 (float4 param0);
+OVERLOADABLE float8 log10 (float8 param0);
+OVERLOADABLE float16 log10 (float16 param0);
+OVERLOADABLE double2 log10 (double2 param0);
+OVERLOADABLE double3 log10 (double3 param0);
+OVERLOADABLE double4 log10 (double4 param0);
+OVERLOADABLE double8 log10 (double8 param0);
+OVERLOADABLE double16 log10 (double16 param0);
+OVERLOADABLE half2 log10 (half2 param0);
+OVERLOADABLE half3 log10 (half3 param0);
+OVERLOADABLE half4 log10 (half4 param0);
+OVERLOADABLE half8 log10 (half8 param0);
+OVERLOADABLE half16 log10 (half16 param0);
+
+//gentype log1p (gentype x)
+
+OVERLOADABLE float2 log1p (float2 param0);
+OVERLOADABLE float3 log1p (float3 param0);
+OVERLOADABLE float4 log1p (float4 param0);
+OVERLOADABLE float8 log1p (float8 param0);
+OVERLOADABLE float16 log1p (float16 param0);
+OVERLOADABLE double2 log1p (double2 param0);
+OVERLOADABLE double3 log1p (double3 param0);
+OVERLOADABLE double4 log1p (double4 param0);
+OVERLOADABLE double8 log1p (double8 param0);
+OVERLOADABLE double16 log1p (double16 param0);
+OVERLOADABLE half2 log1p (half2 param0);
+OVERLOADABLE half3 log1p (half3 param0);
+OVERLOADABLE half4 log1p (half4 param0);
+OVERLOADABLE half8 log1p (half8 param0);
+OVERLOADABLE half16 log1p (half16 param0);
+
+//gentype logb (gentype x)
+
+OVERLOADABLE float2 logb (float2 param0);
+OVERLOADABLE float3 logb (float3 param0);
+OVERLOADABLE float4 logb (float4 param0);
+OVERLOADABLE float8 logb (float8 param0);
+OVERLOADABLE float16 logb (float16 param0);
+OVERLOADABLE double2 logb (double2 param0);
+OVERLOADABLE double3 logb (double3 param0);
+OVERLOADABLE double4 logb (double4 param0);
+OVERLOADABLE double8 logb (double8 param0);
+OVERLOADABLE double16 logb (double16 param0);
+OVERLOADABLE half2 logb (half2 param0);
+OVERLOADABLE half3 logb (half3 param0);
+OVERLOADABLE half4 logb (half4 param0);
+OVERLOADABLE half8 logb (half8 param0);
+OVERLOADABLE half16 logb (half16 param0);
+
+//gentype mad (gentype a, gentype b, gentype c)
+
+OVERLOADABLE float2 mad (float2 param0, float2 param1, float2 param2);
+OVERLOADABLE float3 mad (float3 param0, float3 param1, float3 param2);
+OVERLOADABLE float4 mad (float4 param0, float4 param1, float4 param2);
+OVERLOADABLE float8 mad (float8 param0, float8 param1, float8 param2);
+OVERLOADABLE float16 mad (float16 param0, float16 param1, float16 param2);
+OVERLOADABLE double2 mad (double2 param0, double2 param1, double2 param2);
+OVERLOADABLE double3 mad (double3 param0, double3 param1, double3 param2);
+OVERLOADABLE double4 mad (double4 param0, double4 param1, double4 param2);
+OVERLOADABLE double8 mad (double8 param0, double8 param1, double8 param2);
+OVERLOADABLE double16 mad (double16 param0, double16 param1, double16 param2);
+OVERLOADABLE half2 mad (half2 param0, half2 param1, half2 param2);
+OVERLOADABLE half3 mad (half3 param0, half3 param1, half3 param2);
+OVERLOADABLE half4 mad (half4 param0, half4 param1, half4 param2);
+OVERLOADABLE half8 mad (half8 param0, half8 param1, half8 param2);
+OVERLOADABLE half16 mad (half16 param0, half16 param1, half16 param2);
+
+//gentype maxmag (gentype x, gentype y)
+
+OVERLOADABLE float2 maxmag (float2 param0, float2 param1);
+OVERLOADABLE float3 maxmag (float3 param0, float3 param1);
+OVERLOADABLE float4 maxmag (float4 param0, float4 param1);
+OVERLOADABLE float8 maxmag (float8 param0, float8 param1);
+OVERLOADABLE float16 maxmag (float16 param0, float16 param1);
+OVERLOADABLE double2 maxmag (double2 param0, double2 param1);
+OVERLOADABLE double3 maxmag (double3 param0, double3 param1);
+OVERLOADABLE double4 maxmag (double4 param0, double4 param1);
+OVERLOADABLE double8 maxmag (double8 param0, double8 param1);
+OVERLOADABLE double16 maxmag (double16 param0, double16 param1);
+OVERLOADABLE half2 maxmag (half2 param0, half2 param1);
+OVERLOADABLE half3 maxmag (half3 param0, half3 param1);
+OVERLOADABLE half4 maxmag (half4 param0, half4 param1);
+OVERLOADABLE half8 maxmag (half8 param0, half8 param1);
+OVERLOADABLE half16 maxmag (half16 param0, half16 param1);
+
+//gentype minmag (gentype x, gentype y)
+
+OVERLOADABLE float2 minmag (float2 param0, float2 param1);
+OVERLOADABLE float3 minmag (float3 param0, float3 param1);
+OVERLOADABLE float4 minmag (float4 param0, float4 param1);
+OVERLOADABLE float8 minmag (float8 param0, float8 param1);
+OVERLOADABLE float16 minmag (float16 param0, float16 param1);
+OVERLOADABLE double2 minmag (double2 param0, double2 param1);
+OVERLOADABLE double3 minmag (double3 param0, double3 param1);
+OVERLOADABLE double4 minmag (double4 param0, double4 param1);
+OVERLOADABLE double8 minmag (double8 param0, double8 param1);
+OVERLOADABLE double16 minmag (double16 param0, double16 param1);
+OVERLOADABLE half2 minmag (half2 param0, half2 param1);
+OVERLOADABLE half3 minmag (half3 param0, half3 param1);
+OVERLOADABLE half4 minmag (half4 param0, half4 param1);
+OVERLOADABLE half8 minmag (half8 param0, half8 param1);
+OVERLOADABLE half16 minmag (half16 param0, half16 param1);
+
+//floatn nan (uintn nancode)
+
+OVERLOADABLE float2 nan (uint2 param0);
+OVERLOADABLE float3 nan (uint3 param0);
+OVERLOADABLE float4 nan (uint4 param0);
+OVERLOADABLE float8 nan (uint8 param0);
+OVERLOADABLE float16 nan (uint16 param0);
+
+//float nan (uint nancode)
+
+
+//halfn nan (ushortn nancode)
+
+OVERLOADABLE half2 nan (ushort2 param0);
+OVERLOADABLE half3 nan (ushort3 param0);
+OVERLOADABLE half4 nan (ushort4 param0);
+OVERLOADABLE half8 nan (ushort8 param0);
+OVERLOADABLE half16 nan (ushort16 param0);
+
+//half nan (ushort nancode)
+
+
+//double nan (ulong nancode)
+
+
+//gentype nextafter (gentype x, gentype y)
+
+OVERLOADABLE float2 nextafter (float2 param0, float2 param1);
+OVERLOADABLE float3 nextafter (float3 param0, float3 param1);
+OVERLOADABLE float4 nextafter (float4 param0, float4 param1);
+OVERLOADABLE float8 nextafter (float8 param0, float8 param1);
+OVERLOADABLE float16 nextafter (float16 param0, float16 param1);
+OVERLOADABLE double2 nextafter (double2 param0, double2 param1);
+OVERLOADABLE double3 nextafter (double3 param0, double3 param1);
+OVERLOADABLE double4 nextafter (double4 param0, double4 param1);
+OVERLOADABLE double8 nextafter (double8 param0, double8 param1);
+OVERLOADABLE double16 nextafter (double16 param0, double16 param1);
+OVERLOADABLE half2 nextafter (half2 param0, half2 param1);
+OVERLOADABLE half3 nextafter (half3 param0, half3 param1);
+OVERLOADABLE half4 nextafter (half4 param0, half4 param1);
+OVERLOADABLE half8 nextafter (half8 param0, half8 param1);
+OVERLOADABLE half16 nextafter (half16 param0, half16 param1);
+
+//gentype pow (gentype x, gentype y)
+
+OVERLOADABLE float2 pow (float2 param0, float2 param1);
+OVERLOADABLE float3 pow (float3 param0, float3 param1);
+OVERLOADABLE float4 pow (float4 param0, float4 param1);
+OVERLOADABLE float8 pow (float8 param0, float8 param1);
+OVERLOADABLE float16 pow (float16 param0, float16 param1);
+OVERLOADABLE double2 pow (double2 param0, double2 param1);
+OVERLOADABLE double3 pow (double3 param0, double3 param1);
+OVERLOADABLE double4 pow (double4 param0, double4 param1);
+OVERLOADABLE double8 pow (double8 param0, double8 param1);
+OVERLOADABLE double16 pow (double16 param0, double16 param1);
+OVERLOADABLE half2 pow (half2 param0, half2 param1);
+OVERLOADABLE half3 pow (half3 param0, half3 param1);
+OVERLOADABLE half4 pow (half4 param0, half4 param1);
+OVERLOADABLE half8 pow (half8 param0, half8 param1);
+OVERLOADABLE half16 pow (half16 param0, half16 param1);
+
+//floatn pown (floatn x, intn y)
+
+OVERLOADABLE float2 pown (float2 param0, int2 param1);
+OVERLOADABLE float3 pown (float3 param0, int3 param1);
+OVERLOADABLE float4 pown (float4 param0, int4 param1);
+OVERLOADABLE float8 pown (float8 param0, int8 param1);
+OVERLOADABLE float16 pown (float16 param0, int16 param1);
+
+//float pown (float x, int y)
+
+
+//halfn pown (halfn x, intn y)
+
+OVERLOADABLE half2 pown (half2 param0, int2 param1);
+OVERLOADABLE half3 pown (half3 param0, int3 param1);
+OVERLOADABLE half4 pown (half4 param0, int4 param1);
+OVERLOADABLE half8 pown (half8 param0, int8 param1);
+OVERLOADABLE half16 pown (half16 param0, int16 param1);
+
+//half pown (half x, int y)
+
+
+//double pown (double x, int y)
+
+
+//gentype powr (gentype x, gentype y)
+
+OVERLOADABLE float2 powr (float2 param0, float2 param1);
+OVERLOADABLE float3 powr (float3 param0, float3 param1);
+OVERLOADABLE float4 powr (float4 param0, float4 param1);
+OVERLOADABLE float8 powr (float8 param0, float8 param1);
+OVERLOADABLE float16 powr (float16 param0, float16 param1);
+OVERLOADABLE double2 powr (double2 param0, double2 param1);
+OVERLOADABLE double3 powr (double3 param0, double3 param1);
+OVERLOADABLE double4 powr (double4 param0, double4 param1);
+OVERLOADABLE double8 powr (double8 param0, double8 param1);
+OVERLOADABLE double16 powr (double16 param0, double16 param1);
+OVERLOADABLE half2 powr (half2 param0, half2 param1);
+OVERLOADABLE half3 powr (half3 param0, half3 param1);
+OVERLOADABLE half4 powr (half4 param0, half4 param1);
+OVERLOADABLE half8 powr (half8 param0, half8 param1);
+OVERLOADABLE half16 powr (half16 param0, half16 param1);
+
+//gentype remainder (gentype x, gentype y)
+
+OVERLOADABLE float2 remainder (float2 param0, float2 param1);
+OVERLOADABLE float3 remainder (float3 param0, float3 param1);
+OVERLOADABLE float4 remainder (float4 param0, float4 param1);
+OVERLOADABLE float8 remainder (float8 param0, float8 param1);
+OVERLOADABLE float16 remainder (float16 param0, float16 param1);
+OVERLOADABLE double2 remainder (double2 param0, double2 param1);
+OVERLOADABLE double3 remainder (double3 param0, double3 param1);
+OVERLOADABLE double4 remainder (double4 param0, double4 param1);
+OVERLOADABLE double8 remainder (double8 param0, double8 param1);
+OVERLOADABLE double16 remainder (double16 param0, double16 param1);
+OVERLOADABLE half2 remainder (half2 param0, half2 param1);
+OVERLOADABLE half3 remainder (half3 param0, half3 param1);
+OVERLOADABLE half4 remainder (half4 param0, half4 param1);
+OVERLOADABLE half8 remainder (half8 param0, half8 param1);
+OVERLOADABLE half16 remainder (half16 param0, half16 param1);
+
+//gentype rint (gentype)
+
+OVERLOADABLE float2 rint (float2 param0);
+OVERLOADABLE float3 rint (float3 param0);
+OVERLOADABLE float4 rint (float4 param0);
+OVERLOADABLE float8 rint (float8 param0);
+OVERLOADABLE float16 rint (float16 param0);
+OVERLOADABLE double2 rint (double2 param0);
+OVERLOADABLE double3 rint (double3 param0);
+OVERLOADABLE double4 rint (double4 param0);
+OVERLOADABLE double8 rint (double8 param0);
+OVERLOADABLE double16 rint (double16 param0);
+OVERLOADABLE half2 rint (half2 param0);
+OVERLOADABLE half3 rint (half3 param0);
+OVERLOADABLE half4 rint (half4 param0);
+OVERLOADABLE half8 rint (half8 param0);
+OVERLOADABLE half16 rint (half16 param0);
+
+//floatn rootn (floatn x, intn y)
+
+OVERLOADABLE float2 rootn (float2 param0, int2 param1);
+OVERLOADABLE float3 rootn (float3 param0, int3 param1);
+OVERLOADABLE float4 rootn (float4 param0, int4 param1);
+OVERLOADABLE float8 rootn (float8 param0, int8 param1);
+OVERLOADABLE float16 rootn (float16 param0, int16 param1);
+
+//halfn rootn (halfn x, intn y)
+
+OVERLOADABLE half2 rootn (half2 param0, int2 param1);
+OVERLOADABLE half3 rootn (half3 param0, int3 param1);
+OVERLOADABLE half4 rootn (half4 param0, int4 param1);
+OVERLOADABLE half8 rootn (half8 param0, int8 param1);
+OVERLOADABLE half16 rootn (half16 param0, int16 param1);
+
+//gentype round (gentype x)
+
+OVERLOADABLE float2 round (float2 param0);
+OVERLOADABLE float3 round (float3 param0);
+OVERLOADABLE float4 round (float4 param0);
+OVERLOADABLE float8 round (float8 param0);
+OVERLOADABLE float16 round (float16 param0);
+OVERLOADABLE double2 round (double2 param0);
+OVERLOADABLE double3 round (double3 param0);
+OVERLOADABLE double4 round (double4 param0);
+OVERLOADABLE double8 round (double8 param0);
+OVERLOADABLE double16 round (double16 param0);
+OVERLOADABLE half2 round (half2 param0);
+OVERLOADABLE half3 round (half3 param0);
+OVERLOADABLE half4 round (half4 param0);
+OVERLOADABLE half8 round (half8 param0);
+OVERLOADABLE half16 round (half16 param0);
+
+//gentype rsqrt (gentype)
+
+OVERLOADABLE float2 rsqrt (float2 param0);
+OVERLOADABLE float3 rsqrt (float3 param0);
+OVERLOADABLE float4 rsqrt (float4 param0);
+OVERLOADABLE float8 rsqrt (float8 param0);
+OVERLOADABLE float16 rsqrt (float16 param0);
+OVERLOADABLE double2 rsqrt (double2 param0);
+OVERLOADABLE double3 rsqrt (double3 param0);
+OVERLOADABLE double4 rsqrt (double4 param0);
+OVERLOADABLE double8 rsqrt (double8 param0);
+OVERLOADABLE double16 rsqrt (double16 param0);
+OVERLOADABLE half2 rsqrt (half2 param0);
+OVERLOADABLE half3 rsqrt (half3 param0);
+OVERLOADABLE half4 rsqrt (half4 param0);
+OVERLOADABLE half8 rsqrt (half8 param0);
+OVERLOADABLE half16 rsqrt (half16 param0);
+
+//gentype sin (gentype)
+
+OVERLOADABLE float2 sin (float2 param0);
+OVERLOADABLE float3 sin (float3 param0);
+OVERLOADABLE float4 sin (float4 param0);
+OVERLOADABLE float8 sin (float8 param0);
+OVERLOADABLE float16 sin (float16 param0);
+OVERLOADABLE double2 sin (double2 param0);
+OVERLOADABLE double3 sin (double3 param0);
+OVERLOADABLE double4 sin (double4 param0);
+OVERLOADABLE double8 sin (double8 param0);
+OVERLOADABLE double16 sin (double16 param0);
+OVERLOADABLE half2 sin (half2 param0);
+OVERLOADABLE half3 sin (half3 param0);
+OVERLOADABLE half4 sin (half4 param0);
+OVERLOADABLE half8 sin (half8 param0);
+OVERLOADABLE half16 sin (half16 param0);
+
+//gentype sinh (gentype)
+
+OVERLOADABLE float2 sinh (float2 param0);
+OVERLOADABLE float3 sinh (float3 param0);
+OVERLOADABLE float4 sinh (float4 param0);
+OVERLOADABLE float8 sinh (float8 param0);
+OVERLOADABLE float16 sinh (float16 param0);
+OVERLOADABLE double2 sinh (double2 param0);
+OVERLOADABLE double3 sinh (double3 param0);
+OVERLOADABLE double4 sinh (double4 param0);
+OVERLOADABLE double8 sinh (double8 param0);
+OVERLOADABLE double16 sinh (double16 param0);
+OVERLOADABLE half2 sinh (half2 param0);
+OVERLOADABLE half3 sinh (half3 param0);
+OVERLOADABLE half4 sinh (half4 param0);
+OVERLOADABLE half8 sinh (half8 param0);
+OVERLOADABLE half16 sinh (half16 param0);
+
+//gentype sinpi (gentype x)
+
+OVERLOADABLE float2 sinpi (float2 param0);
+OVERLOADABLE float3 sinpi (float3 param0);
+OVERLOADABLE float4 sinpi (float4 param0);
+OVERLOADABLE float8 sinpi (float8 param0);
+OVERLOADABLE float16 sinpi (float16 param0);
+OVERLOADABLE double2 sinpi (double2 param0);
+OVERLOADABLE double3 sinpi (double3 param0);
+OVERLOADABLE double4 sinpi (double4 param0);
+OVERLOADABLE double8 sinpi (double8 param0);
+OVERLOADABLE double16 sinpi (double16 param0);
+OVERLOADABLE half2 sinpi (half2 param0);
+OVERLOADABLE half3 sinpi (half3 param0);
+OVERLOADABLE half4 sinpi (half4 param0);
+OVERLOADABLE half8 sinpi (half8 param0);
+OVERLOADABLE half16 sinpi (half16 param0);
+
+//gentype sqrt (gentype)
+
+OVERLOADABLE float2 sqrt (float2 param0);
+OVERLOADABLE float3 sqrt (float3 param0);
+OVERLOADABLE float4 sqrt (float4 param0);
+OVERLOADABLE float8 sqrt (float8 param0);
+OVERLOADABLE float16 sqrt (float16 param0);
+OVERLOADABLE double2 sqrt (double2 param0);
+OVERLOADABLE double3 sqrt (double3 param0);
+OVERLOADABLE double4 sqrt (double4 param0);
+OVERLOADABLE double8 sqrt (double8 param0);
+OVERLOADABLE double16 sqrt (double16 param0);
+OVERLOADABLE half2 sqrt (half2 param0);
+OVERLOADABLE half3 sqrt (half3 param0);
+OVERLOADABLE half4 sqrt (half4 param0);
+OVERLOADABLE half8 sqrt (half8 param0);
+OVERLOADABLE half16 sqrt (half16 param0);
+
+//gentype tan (gentype)
+
+OVERLOADABLE float2 tan (float2 param0);
+OVERLOADABLE float3 tan (float3 param0);
+OVERLOADABLE float4 tan (float4 param0);
+OVERLOADABLE float8 tan (float8 param0);
+OVERLOADABLE float16 tan (float16 param0);
+OVERLOADABLE double2 tan (double2 param0);
+OVERLOADABLE double3 tan (double3 param0);
+OVERLOADABLE double4 tan (double4 param0);
+OVERLOADABLE double8 tan (double8 param0);
+OVERLOADABLE double16 tan (double16 param0);
+OVERLOADABLE half2 tan (half2 param0);
+OVERLOADABLE half3 tan (half3 param0);
+OVERLOADABLE half4 tan (half4 param0);
+OVERLOADABLE half8 tan (half8 param0);
+OVERLOADABLE half16 tan (half16 param0);
+
+//gentype tanh (gentype)
+
+OVERLOADABLE float2 tanh (float2 param0);
+OVERLOADABLE float3 tanh (float3 param0);
+OVERLOADABLE float4 tanh (float4 param0);
+OVERLOADABLE float8 tanh (float8 param0);
+OVERLOADABLE float16 tanh (float16 param0);
+OVERLOADABLE double2 tanh (double2 param0);
+OVERLOADABLE double3 tanh (double3 param0);
+OVERLOADABLE double4 tanh (double4 param0);
+OVERLOADABLE double8 tanh (double8 param0);
+OVERLOADABLE double16 tanh (double16 param0);
+OVERLOADABLE half2 tanh (half2 param0);
+OVERLOADABLE half3 tanh (half3 param0);
+OVERLOADABLE half4 tanh (half4 param0);
+OVERLOADABLE half8 tanh (half8 param0);
+OVERLOADABLE half16 tanh (half16 param0);
+
+//gentype tanpi (gentype x)
+
+OVERLOADABLE float2 tanpi (float2 param0);
+OVERLOADABLE float3 tanpi (float3 param0);
+OVERLOADABLE float4 tanpi (float4 param0);
+OVERLOADABLE float8 tanpi (float8 param0);
+OVERLOADABLE float16 tanpi (float16 param0);
+OVERLOADABLE double2 tanpi (double2 param0);
+OVERLOADABLE double3 tanpi (double3 param0);
+OVERLOADABLE double4 tanpi (double4 param0);
+OVERLOADABLE double8 tanpi (double8 param0);
+OVERLOADABLE double16 tanpi (double16 param0);
+OVERLOADABLE half2 tanpi (half2 param0);
+OVERLOADABLE half3 tanpi (half3 param0);
+OVERLOADABLE half4 tanpi (half4 param0);
+OVERLOADABLE half8 tanpi (half8 param0);
+OVERLOADABLE half16 tanpi (half16 param0);
+
+//gentype tgamma (gentype)
+
+OVERLOADABLE float2 tgamma (float2 param0);
+OVERLOADABLE float3 tgamma (float3 param0);
+OVERLOADABLE float4 tgamma (float4 param0);
+OVERLOADABLE float8 tgamma (float8 param0);
+OVERLOADABLE float16 tgamma (float16 param0);
+OVERLOADABLE double2 tgamma (double2 param0);
+OVERLOADABLE double3 tgamma (double3 param0);
+OVERLOADABLE double4 tgamma (double4 param0);
+OVERLOADABLE double8 tgamma (double8 param0);
+OVERLOADABLE double16 tgamma (double16 param0);
+OVERLOADABLE half2 tgamma (half2 param0);
+OVERLOADABLE half3 tgamma (half3 param0);
+OVERLOADABLE half4 tgamma (half4 param0);
+OVERLOADABLE half8 tgamma (half8 param0);
+OVERLOADABLE half16 tgamma (half16 param0);
+
+//gentype trunc (gentype)
+
+OVERLOADABLE float2 trunc (float2 param0);
+OVERLOADABLE float3 trunc (float3 param0);
+OVERLOADABLE float4 trunc (float4 param0);
+OVERLOADABLE float8 trunc (float8 param0);
+OVERLOADABLE float16 trunc (float16 param0);
+OVERLOADABLE double2 trunc (double2 param0);
+OVERLOADABLE double3 trunc (double3 param0);
+OVERLOADABLE double4 trunc (double4 param0);
+OVERLOADABLE double8 trunc (double8 param0);
+OVERLOADABLE double16 trunc (double16 param0);
+OVERLOADABLE half2 trunc (half2 param0);
+OVERLOADABLE half3 trunc (half3 param0);
+OVERLOADABLE half4 trunc (half4 param0);
+OVERLOADABLE half8 trunc (half8 param0);
+OVERLOADABLE half16 trunc (half16 param0);
+
+//gentype native_cos (gentype x)
+
+OVERLOADABLE float2 native_cos (float2 param0);
+OVERLOADABLE float3 native_cos (float3 param0);
+OVERLOADABLE float4 native_cos (float4 param0);
+OVERLOADABLE float8 native_cos (float8 param0);
+OVERLOADABLE float16 native_cos (float16 param0);
+OVERLOADABLE half2 native_cos (half2 param0);
+OVERLOADABLE half3 native_cos (half3 param0);
+OVERLOADABLE half4 native_cos (half4 param0);
+OVERLOADABLE half8 native_cos (half8 param0);
+OVERLOADABLE half16 native_cos (half16 param0);
+
+//gentype native_divide (gentype x, gentype y)
+
+OVERLOADABLE float2 native_divide (float2 param0, float2 param1);
+OVERLOADABLE float3 native_divide (float3 param0, float3 param1);
+OVERLOADABLE float4 native_divide (float4 param0, float4 param1);
+OVERLOADABLE float8 native_divide (float8 param0, float8 param1);
+OVERLOADABLE float16 native_divide (float16 param0, float16 param1);
+OVERLOADABLE half2 native_divide (half2 param0, half2 param1);
+OVERLOADABLE half3 native_divide (half3 param0, half3 param1);
+OVERLOADABLE half4 native_divide (half4 param0, half4 param1);
+OVERLOADABLE half8 native_divide (half8 param0, half8 param1);
+OVERLOADABLE half16 native_divide (half16 param0, half16 param1);
+
+//gentype native_exp (gentype x)
+
+OVERLOADABLE float2 native_exp (float2 param0);
+OVERLOADABLE float3 native_exp (float3 param0);
+OVERLOADABLE float4 native_exp (float4 param0);
+OVERLOADABLE float8 native_exp (float8 param0);
+OVERLOADABLE float16 native_exp (float16 param0);
+OVERLOADABLE half2 native_exp (half2 param0);
+OVERLOADABLE half3 native_exp (half3 param0);
+OVERLOADABLE half4 native_exp (half4 param0);
+OVERLOADABLE half8 native_exp (half8 param0);
+OVERLOADABLE half16 native_exp (half16 param0);
+
+//gentype native_exp2 (gentype x)
+
+OVERLOADABLE float2 native_exp2 (float2 param0);
+OVERLOADABLE float3 native_exp2 (float3 param0);
+OVERLOADABLE float4 native_exp2 (float4 param0);
+OVERLOADABLE float8 native_exp2 (float8 param0);
+OVERLOADABLE float16 native_exp2 (float16 param0);
+OVERLOADABLE half2 native_exp2 (half2 param0);
+OVERLOADABLE half3 native_exp2 (half3 param0);
+OVERLOADABLE half4 native_exp2 (half4 param0);
+OVERLOADABLE half8 native_exp2 (half8 param0);
+OVERLOADABLE half16 native_exp2 (half16 param0);
+
+//gentype native_exp10 (gentype x)
+
+OVERLOADABLE float2 native_exp10 (float2 param0);
+OVERLOADABLE float3 native_exp10 (float3 param0);
+OVERLOADABLE float4 native_exp10 (float4 param0);
+OVERLOADABLE float8 native_exp10 (float8 param0);
+OVERLOADABLE float16 native_exp10 (float16 param0);
+OVERLOADABLE half2 native_exp10 (half2 param0);
+OVERLOADABLE half3 native_exp10 (half3 param0);
+OVERLOADABLE half4 native_exp10 (half4 param0);
+OVERLOADABLE half8 native_exp10 (half8 param0);
+OVERLOADABLE half16 native_exp10 (half16 param0);
+
+//gentype native_log (gentype x)
+
+OVERLOADABLE float2 native_log (float2 param0);
+OVERLOADABLE float3 native_log (float3 param0);
+OVERLOADABLE float4 native_log (float4 param0);
+OVERLOADABLE float8 native_log (float8 param0);
+OVERLOADABLE float16 native_log (float16 param0);
+OVERLOADABLE half2 native_log (half2 param0);
+OVERLOADABLE half3 native_log (half3 param0);
+OVERLOADABLE half4 native_log (half4 param0);
+OVERLOADABLE half8 native_log (half8 param0);
+OVERLOADABLE half16 native_log (half16 param0);
+
+//gentype native_log2 (gentype x)
+
+OVERLOADABLE float2 native_log2 (float2 param0);
+OVERLOADABLE float3 native_log2 (float3 param0);
+OVERLOADABLE float4 native_log2 (float4 param0);
+OVERLOADABLE float8 native_log2 (float8 param0);
+OVERLOADABLE float16 native_log2 (float16 param0);
+OVERLOADABLE half2 native_log2 (half2 param0);
+OVERLOADABLE half3 native_log2 (half3 param0);
+OVERLOADABLE half4 native_log2 (half4 param0);
+OVERLOADABLE half8 native_log2 (half8 param0);
+OVERLOADABLE half16 native_log2 (half16 param0);
+
+//gentype native_log10 (gentype x)
+
+OVERLOADABLE float2 native_log10 (float2 param0);
+OVERLOADABLE float3 native_log10 (float3 param0);
+OVERLOADABLE float4 native_log10 (float4 param0);
+OVERLOADABLE float8 native_log10 (float8 param0);
+OVERLOADABLE float16 native_log10 (float16 param0);
+OVERLOADABLE half2 native_log10 (half2 param0);
+OVERLOADABLE half3 native_log10 (half3 param0);
+OVERLOADABLE half4 native_log10 (half4 param0);
+OVERLOADABLE half8 native_log10 (half8 param0);
+OVERLOADABLE half16 native_log10 (half16 param0);
+
+//gentype native_powr (gentype x, gentype y)
+
+OVERLOADABLE float2 native_powr (float2 param0, float2 param1);
+OVERLOADABLE float3 native_powr (float3 param0, float3 param1);
+OVERLOADABLE float4 native_powr (float4 param0, float4 param1);
+OVERLOADABLE float8 native_powr (float8 param0, float8 param1);
+OVERLOADABLE float16 native_powr (float16 param0, float16 param1);
+OVERLOADABLE half2 native_powr (half2 param0, half2 param1);
+OVERLOADABLE half3 native_powr (half3 param0, half3 param1);
+OVERLOADABLE half4 native_powr (half4 param0, half4 param1);
+OVERLOADABLE half8 native_powr (half8 param0, half8 param1);
+OVERLOADABLE half16 native_powr (half16 param0, half16 param1);
+
+//gentype native_recip (gentype x)
+
+OVERLOADABLE float2 native_recip (float2 param0);
+OVERLOADABLE float3 native_recip (float3 param0);
+OVERLOADABLE float4 native_recip (float4 param0);
+OVERLOADABLE float8 native_recip (float8 param0);
+OVERLOADABLE float16 native_recip (float16 param0);
+OVERLOADABLE half2 native_recip (half2 param0);
+OVERLOADABLE half3 native_recip (half3 param0);
+OVERLOADABLE half4 native_recip (half4 param0);
+OVERLOADABLE half8 native_recip (half8 param0);
+OVERLOADABLE half16 native_recip (half16 param0);
+
+//gentype native_rsqrt (gentype x)
+
+OVERLOADABLE float2 native_rsqrt (float2 param0);
+OVERLOADABLE float3 native_rsqrt (float3 param0);
+OVERLOADABLE float4 native_rsqrt (float4 param0);
+OVERLOADABLE float8 native_rsqrt (float8 param0);
+OVERLOADABLE float16 native_rsqrt (float16 param0);
+OVERLOADABLE half2 native_rsqrt (half2 param0);
+OVERLOADABLE half3 native_rsqrt (half3 param0);
+OVERLOADABLE half4 native_rsqrt (half4 param0);
+OVERLOADABLE half8 native_rsqrt (half8 param0);
+OVERLOADABLE half16 native_rsqrt (half16 param0);
+
+//gentype native_sin (gentype x)
+
+OVERLOADABLE float2 native_sin (float2 param0);
+OVERLOADABLE float3 native_sin (float3 param0);
+OVERLOADABLE float4 native_sin (float4 param0);
+OVERLOADABLE float8 native_sin (float8 param0);
+OVERLOADABLE float16 native_sin (float16 param0);
+OVERLOADABLE half2 native_sin (half2 param0);
+OVERLOADABLE half3 native_sin (half3 param0);
+OVERLOADABLE half4 native_sin (half4 param0);
+OVERLOADABLE half8 native_sin (half8 param0);
+OVERLOADABLE half16 native_sin (half16 param0);
+
+//gentype native_sqrt (gentype x)
+
+OVERLOADABLE float2 native_sqrt (float2 param0);
+OVERLOADABLE float3 native_sqrt (float3 param0);
+OVERLOADABLE float4 native_sqrt (float4 param0);
+OVERLOADABLE float8 native_sqrt (float8 param0);
+OVERLOADABLE float16 native_sqrt (float16 param0);
+OVERLOADABLE half2 native_sqrt (half2 param0);
+OVERLOADABLE half3 native_sqrt (half3 param0);
+OVERLOADABLE half4 native_sqrt (half4 param0);
+OVERLOADABLE half8 native_sqrt (half8 param0);
+OVERLOADABLE half16 native_sqrt (half16 param0);
+
+//gentype native_tan (gentype x)
+
+OVERLOADABLE float2 native_tan (float2 param0);
+OVERLOADABLE float3 native_tan (float3 param0);
+OVERLOADABLE float4 native_tan (float4 param0);
+OVERLOADABLE float8 native_tan (float8 param0);
+OVERLOADABLE float16 native_tan (float16 param0);
+OVERLOADABLE half2 native_tan (half2 param0);
+OVERLOADABLE half3 native_tan (half3 param0);
+OVERLOADABLE half4 native_tan (half4 param0);
+OVERLOADABLE half8 native_tan (half8 param0);
+OVERLOADABLE half16 native_tan (half16 param0);
+
+//half_native_math builtin functions
+//gentype half_cos (gentype x)
+
+OVERLOADABLE float2 half_cos (float2 param0);
+OVERLOADABLE float3 half_cos (float3 param0);
+OVERLOADABLE float4 half_cos (float4 param0);
+OVERLOADABLE float8 half_cos (float8 param0);
+OVERLOADABLE float16 half_cos (float16 param0);
+
+//gentype half_divide (gentype x, gentype y)
+
+OVERLOADABLE float2 half_divide (float2 param0, float2 param1);
+OVERLOADABLE float3 half_divide (float3 param0, float3 param1);
+OVERLOADABLE float4 half_divide (float4 param0, float4 param1);
+OVERLOADABLE float8 half_divide (float8 param0, float8 param1);
+OVERLOADABLE float16 half_divide (float16 param0, float16 param1);
+
+//gentype half_exp (gentype x)
+
+OVERLOADABLE float2 half_exp (float2 param0);
+OVERLOADABLE float3 half_exp (float3 param0);
+OVERLOADABLE float4 half_exp (float4 param0);
+OVERLOADABLE float8 half_exp (float8 param0);
+OVERLOADABLE float16 half_exp (float16 param0);
+
+//gentype half_exp2 (gentype x)
+
+OVERLOADABLE float2 half_exp2 (float2 param0);
+OVERLOADABLE float3 half_exp2 (float3 param0);
+OVERLOADABLE float4 half_exp2 (float4 param0);
+OVERLOADABLE float8 half_exp2 (float8 param0);
+OVERLOADABLE float16 half_exp2 (float16 param0);
+
+//gentype half_exp10 (gentype x)
+
+OVERLOADABLE float2 half_exp10 (float2 param0);
+OVERLOADABLE float3 half_exp10 (float3 param0);
+OVERLOADABLE float4 half_exp10 (float4 param0);
+OVERLOADABLE float8 half_exp10 (float8 param0);
+OVERLOADABLE float16 half_exp10 (float16 param0);
+
+//gentype half_log (gentype x)
+
+OVERLOADABLE float2 half_log (float2 param0);
+OVERLOADABLE float3 half_log (float3 param0);
+OVERLOADABLE float4 half_log (float4 param0);
+OVERLOADABLE float8 half_log (float8 param0);
+OVERLOADABLE float16 half_log (float16 param0);
+
+//gentype half_log2 (gentype x)
+
+OVERLOADABLE float2 half_log2 (float2 param0);
+OVERLOADABLE float3 half_log2 (float3 param0);
+OVERLOADABLE float4 half_log2 (float4 param0);
+OVERLOADABLE float8 half_log2 (float8 param0);
+OVERLOADABLE float16 half_log2 (float16 param0);
+
+//gentype half_log10 (gentype x)
+
+OVERLOADABLE float2 half_log10 (float2 param0);
+OVERLOADABLE float3 half_log10 (float3 param0);
+OVERLOADABLE float4 half_log10 (float4 param0);
+OVERLOADABLE float8 half_log10 (float8 param0);
+OVERLOADABLE float16 half_log10 (float16 param0);
+
+//gentype half_powr (gentype x, gentype y)
+
+OVERLOADABLE float2 half_powr (float2 param0, float2 param1);
+OVERLOADABLE float3 half_powr (float3 param0, float3 param1);
+OVERLOADABLE float4 half_powr (float4 param0, float4 param1);
+OVERLOADABLE float8 half_powr (float8 param0, float8 param1);
+OVERLOADABLE float16 half_powr (float16 param0, float16 param1);
+
+//gentype half_recip (gentype x)
+
+OVERLOADABLE float2 half_recip (float2 param0);
+OVERLOADABLE float3 half_recip (float3 param0);
+OVERLOADABLE float4 half_recip (float4 param0);
+OVERLOADABLE float8 half_recip (float8 param0);
+OVERLOADABLE float16 half_recip (float16 param0);
+
+//gentype half_rsqrt (gentype x)
+
+OVERLOADABLE float2 half_rsqrt (float2 param0);
+OVERLOADABLE float3 half_rsqrt (float3 param0);
+OVERLOADABLE float4 half_rsqrt (float4 param0);
+OVERLOADABLE float8 half_rsqrt (float8 param0);
+OVERLOADABLE float16 half_rsqrt (float16 param0);
+
+//gentype half_sin (gentype x)
+
+OVERLOADABLE float2 half_sin (float2 param0);
+OVERLOADABLE float3 half_sin (float3 param0);
+OVERLOADABLE float4 half_sin (float4 param0);
+OVERLOADABLE float8 half_sin (float8 param0);
+OVERLOADABLE float16 half_sin (float16 param0);
+
+//gentype half_sqrt (gentype x)
+
+OVERLOADABLE float2 half_sqrt (float2 param0);
+OVERLOADABLE float3 half_sqrt (float3 param0);
+OVERLOADABLE float4 half_sqrt (float4 param0);
+OVERLOADABLE float8 half_sqrt (float8 param0);
+OVERLOADABLE float16 half_sqrt (float16 param0);
+
+//gentype half_tan (gentype x)
+
+OVERLOADABLE float2 half_tan (float2 param0);
+OVERLOADABLE float3 half_tan (float3 param0);
+OVERLOADABLE float4 half_tan (float4 param0);
+OVERLOADABLE float8 half_tan (float8 param0);
+OVERLOADABLE float16 half_tan (float16 param0);
+
+//double acos (double)
+
+
+//double acosh (double)
+
+
+//double acospi (double x)
+
+
+//double asin (double)
+
+
+//double asinh (double)
+
+
+//double asinpi (double x)
+
+
+//double atan (double y_over_x)
+
+
+//double atan2 (double y, double x)
+
+
+//double atanh (double)
+
+
+//double atanpi (double x)
+
+
+//double atan2pi (double y, double x)
+
+
+//double cbrt (double)
+
+
+//double ceil (double)
+
+
+//double copysign (double x, double y)
+
+
+//double cos (double)
+
+
+//double cosh (double)
+
+
+//double cospi (double x)
+
+
+//double erfc (double)
+
+
+//double erf (double)
+
+
+//double exp (double x)
+
+
+//double exp2 (double)
+
+
+//double exp10 (double)
+
+
+//double expm1 (double x)
+
+
+//double fabs (double)
+
+
+//double fdim (double x, double y)
+
+
+//double floor (double)
+
+
+//double fma (double a, double b, double c)
+
+
+//double fmax (double x, double y)
+
+
+//double fmax (double x, double y)
+
+
+//double fmin (double x, double y)
+
+
+//double fmin (double x, double y)
+
+
+//double fmod (double x, double y)
+
+
+//double hypot (double x, double y)
+
+
+//intn ilogb (doublen x)
+
+OVERLOADABLE int2 ilogb (double2 param0);
+OVERLOADABLE int3 ilogb (double3 param0);
+OVERLOADABLE int4 ilogb (double4 param0);
+OVERLOADABLE int8 ilogb (double8 param0);
+OVERLOADABLE int16 ilogb (double16 param0);
+
+//int ilogb (double x)
+
+
+//doublen ldexp (doublen x, intn k)
+
+OVERLOADABLE double2 ldexp (double2 param0, int2 param1);
+OVERLOADABLE double3 ldexp (double3 param0, int3 param1);
+OVERLOADABLE double4 ldexp (double4 param0, int4 param1);
+OVERLOADABLE double8 ldexp (double8 param0, int8 param1);
+OVERLOADABLE double16 ldexp (double16 param0, int16 param1);
+
+//doublen ldexp (doublen x, int k)
+
+OVERLOADABLE double2 ldexp (double2 param0, int param1);
+OVERLOADABLE double3 ldexp (double3 param0, int param1);
+OVERLOADABLE double4 ldexp (double4 param0, int param1);
+OVERLOADABLE double8 ldexp (double8 param0, int param1);
+OVERLOADABLE double16 ldexp (double16 param0, int param1);
+
+//double ldexp (double x, int k)
+
+
+//double lgamma (double x)
+
+
+//double log (double)
+
+
+//double log2 (double)
+
+
+//double log10 (double)
+
+
+//double log1p (double x)
+
+
+//double logb (double x)
+
+
+//double mad (double a, double b, double c)
+
+
+//double maxmag (double x, double y)
+
+
+//double minmag (double x, double y)
+
+
+//double modf (double x,  double *iptr)
+
+
+//doublen nan (ulongn nancode)
+
+OVERLOADABLE double2 nan (ulong2 param0);
+OVERLOADABLE double3 nan (ulong3 param0);
+OVERLOADABLE double4 nan (ulong4 param0);
+OVERLOADABLE double8 nan (ulong8 param0);
+OVERLOADABLE double16 nan (ulong16 param0);
+
+//double nan (ulong nancode)
+
+
+//double nextafter (double x, double y)
+
+
+//double pow (double x, double y)
+
+
+//doublen pown (doublen x, intn y)
+
+OVERLOADABLE double2 pown (double2 param0, int2 param1);
+OVERLOADABLE double3 pown (double3 param0, int3 param1);
+OVERLOADABLE double4 pown (double4 param0, int4 param1);
+OVERLOADABLE double8 pown (double8 param0, int8 param1);
+OVERLOADABLE double16 pown (double16 param0, int16 param1);
+
+//double pown (double x, int y)
+
+
+//double powr (double x, double y)
+
+
+//double remainder (double x, double y)
+
+
+//double rint (double)
+
+
+//doublen rootn (doublen x, intn y)
+
+OVERLOADABLE double2 rootn (double2 param0, int2 param1);
+OVERLOADABLE double3 rootn (double3 param0, int3 param1);
+OVERLOADABLE double4 rootn (double4 param0, int4 param1);
+OVERLOADABLE double8 rootn (double8 param0, int8 param1);
+OVERLOADABLE double16 rootn (double16 param0, int16 param1);
+
+//double rootn (double x, int y)
+
+
+//double round (double x)
+
+
+//double rsqrt (double)
+
+
+//double sin (double)
+
+
+//double sincos (double x,  double *cosval)
+
+
+//double sinh (double)
+
+
+//double sinpi (double x)
+
+
+//double sqrt (double)
+
+
+//double tan (double)
+
+
+//double tanh (double)
+
+
+//double tanpi (double x)
+
+
+//double tgamma (double)
+
+
+//double trunc (double)
+
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_memcpy.h b/drivers/pocl-gen7/lib/beignet/include/ocl_memcpy.h
new file mode 100644
index 0000000..2672298
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_memcpy.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_MEMCPY_H__
+#define __OCL_MEMCPY_H__
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// memcopy functions
+/////////////////////////////////////////////////////////////////////////////
+void __gen_memcpy_gg_align(__global uchar* dst, __global uchar* src, size_t size);
+void __gen_memcpy_gp_align(__global uchar* dst, __private uchar* src, size_t size);
+void __gen_memcpy_gl_align(__global uchar* dst, __local uchar* src, size_t size);
+void __gen_memcpy_gc_align(__global uchar* dst, __constant uchar* src, size_t size);
+void __gen_memcpy_pg_align(__private uchar* dst, __global uchar* src, size_t size);
+void __gen_memcpy_pp_align(__private uchar* dst, __private uchar* src, size_t size);
+void __gen_memcpy_pl_align(__private uchar* dst, __local uchar* src, size_t size);
+void __gen_memcpy_pc_align(__private uchar* dst, __constant uchar* src, size_t size);
+void __gen_memcpy_lg_align(__local uchar* dst, __global uchar* src, size_t size);
+void __gen_memcpy_lp_align(__local uchar* dst, __private uchar* src, size_t size);
+void __gen_memcpy_ll_align(__local uchar* dst, __local uchar* src, size_t size);
+void __gen_memcpy_lc_align(__local uchar* dst, __constant uchar* src, size_t size);
+
+void __gen_memcpy_gg(__global uchar* dst, __global uchar* src, size_t size);
+void __gen_memcpy_gp(__global uchar* dst, __private uchar* src, size_t size);
+void __gen_memcpy_gl(__global uchar* dst, __local uchar* src, size_t size);
+void __gen_memcpy_gc(__global uchar* dst, __constant uchar* src, size_t size);
+void __gen_memcpy_pg(__private uchar* dst, __global uchar* src, size_t size);
+void __gen_memcpy_pp(__private uchar* dst, __private uchar* src, size_t size);
+void __gen_memcpy_pl(__private uchar* dst, __local uchar* src, size_t size);
+void __gen_memcpy_pc(__private uchar* dst, __constant uchar* src, size_t size);
+void __gen_memcpy_lg(__local uchar* dst, __global uchar* src, size_t size);
+void __gen_memcpy_lp(__local uchar* dst, __private uchar* src, size_t size);
+void __gen_memcpy_ll(__local uchar* dst, __local uchar* src, size_t size);
+void __gen_memcpy_lc(__local uchar* dst, __constant uchar* src, size_t size);
+
+#endif  /* __OCL_MEMCPY_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_memset.h b/drivers/pocl-gen7/lib/beignet/include/ocl_memset.h
new file mode 100644
index 0000000..2d444ad
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_memset.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_MEMSET_H__
+#define __OCL_MEMSET_H__
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// memcopy functions
+/////////////////////////////////////////////////////////////////////////////
+void __gen_memset_g_align(__global uchar* dst, uchar val, size_t size);
+void __gen_memset_p_align(__private uchar* dst, uchar val, size_t size);
+void __gen_memset_l_align(__local uchar* dst, uchar val, size_t size);
+
+void __gen_memset_g(__global uchar* dst, uchar val, size_t size);
+void __gen_memset_p(__private uchar* dst, uchar val, size_t size);
+void __gen_memset_l(__local uchar* dst, uchar val, size_t size);
+
+#endif  /* __OCL_MEMSET_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_misc.h b/drivers/pocl-gen7/lib/beignet/include/ocl_misc.h
new file mode 100644
index 0000000..865ad38
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_misc.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_MISC_H__
+#define __OCL_MISC_H__
+
+#include "ocl_types.h"
+
+#define DEC2(TYPE, XTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##2 shuffle(XTYPE x, MASKTYPE##2 mask);
+
+#define DEC4(TYPE, XTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##4 shuffle(XTYPE x, MASKTYPE##4 mask);
+
+#define DEC8(TYPE, XTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##8 shuffle(XTYPE x, MASKTYPE##8 mask);
+
+#define DEC16(TYPE, XTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##16 shuffle(XTYPE x, MASKTYPE##16 mask);
+
+#define DEFMASK(TYPE, MASKTYPE) \
+  DEC2(TYPE, TYPE##2, MASKTYPE); DEC2(TYPE, TYPE##4, MASKTYPE); DEC2(TYPE, TYPE##8, MASKTYPE); DEC2(TYPE, TYPE##16, MASKTYPE) \
+  DEC4(TYPE, TYPE##2, MASKTYPE); DEC4(TYPE, TYPE##4, MASKTYPE); DEC4(TYPE, TYPE##8, MASKTYPE); DEC4(TYPE, TYPE##16, MASKTYPE) \
+  DEC8(TYPE, TYPE##2, MASKTYPE); DEC8(TYPE, TYPE##4, MASKTYPE); DEC8(TYPE, TYPE##8, MASKTYPE); DEC8(TYPE, TYPE##16, MASKTYPE) \
+  DEC16(TYPE, TYPE##2, MASKTYPE); DEC16(TYPE, TYPE##4, MASKTYPE); DEC16(TYPE, TYPE##8, MASKTYPE); DEC16(TYPE, TYPE##16, MASKTYPE)
+
+#define DEF(TYPE) \
+  DEFMASK(TYPE, uchar) \
+  DEFMASK(TYPE, ushort) \
+  DEFMASK(TYPE, uint) \
+  DEFMASK(TYPE, ulong)
+
+DEF(char)
+DEF(uchar)
+DEF(short)
+DEF(ushort)
+DEF(half)
+DEF(int)
+DEF(uint)
+DEF(float)
+DEF(long)
+DEF(ulong)
+DEF(double)
+#undef DEF
+#undef DEFMASK
+#undef DEC2
+#undef DEC4
+#undef DEC8
+#undef DEC16
+
+#define DEC2(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##2 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##2 mask);
+
+#define DEC2X(TYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##2 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##2 mask);
+
+#define DEC4(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##4 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##4 mask);
+
+#define DEC4X(TYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##4 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##4 mask);
+
+#define DEC8(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##8 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##8 mask);
+
+#define DEC8X(TYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##8 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##8 mask);
+
+#define DEC16(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##16 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##16 mask);
+
+#define DEC16X(TYPE, MASKTYPE) \
+  OVERLOADABLE TYPE##16 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##16 mask);
+
+#define DEFMASK(TYPE, MASKTYPE) \
+  DEC2(TYPE, TYPE##2, TYPE##4, MASKTYPE) \
+  DEC2(TYPE, TYPE##4, TYPE##8, MASKTYPE) \
+  DEC2(TYPE, TYPE##8, TYPE##16, MASKTYPE) \
+  DEC2X(TYPE, MASKTYPE) \
+  DEC4(TYPE, TYPE##2, TYPE##4, MASKTYPE) \
+  DEC4(TYPE, TYPE##4, TYPE##8, MASKTYPE) \
+  DEC4(TYPE, TYPE##8, TYPE##16, MASKTYPE) \
+  DEC4X(TYPE, MASKTYPE) \
+  DEC8(TYPE, TYPE##2, TYPE##4, MASKTYPE) \
+  DEC8(TYPE, TYPE##4, TYPE##8, MASKTYPE) \
+  DEC8(TYPE, TYPE##8, TYPE##16, MASKTYPE) \
+  DEC8X(TYPE, MASKTYPE) \
+  DEC16(TYPE, TYPE##2, TYPE##4, MASKTYPE) \
+  DEC16(TYPE, TYPE##4, TYPE##8, MASKTYPE) \
+  DEC16(TYPE, TYPE##8, TYPE##16, MASKTYPE) \
+  DEC16X(TYPE, MASKTYPE)
+
+#define DEF(TYPE) \
+  DEFMASK(TYPE, uchar) \
+  DEFMASK(TYPE, ushort) \
+  DEFMASK(TYPE, uint) \
+  DEFMASK(TYPE, ulong)
+
+DEF(char)
+DEF(uchar)
+DEF(short)
+DEF(ushort)
+DEF(half)
+DEF(int)
+DEF(uint)
+DEF(float)
+DEF(long)
+DEF(ulong)
+DEF(double)
+#undef DEF
+#undef DEFMASK
+#undef DEC2
+#undef DEC2X
+#undef DEC4
+#undef DEC4X
+#undef DEC8
+#undef DEC8X
+#undef DEC16
+#undef DEC16X
+
+struct time_stamp {
+  // time tick
+  ulong tick;
+  // If context-switch or frequency change occurs since last read of tm,
+  // event will be non-zero, otherwise, it will be zero.
+  uint event;
+};
+
+uint __gen_ocl_region(ushort offset, uint data);
+
+struct time_stamp __gen_ocl_get_timestamp(void);
+
+uint8 __gen_ocl_vme(image2d_t, image2d_t,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   uint, uint, uint, uint,
+                   int, int, int);
+
+bool __gen_ocl_in_local(size_t p);
+bool __gen_ocl_in_private(size_t p);
+
+#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300)
+local void *__to_local(generic void *p);
+global void *__to_global(generic void *p);
+private void *__to_private(generic void *p);
+#endif
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_pipe.h b/drivers/pocl-gen7/lib/beignet/include/ocl_pipe.h
new file mode 100644
index 0000000..349b1dd
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_pipe.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_PIPE_H__
+#define __OCL_PIPE_H__
+
+#include "ocl_types.h"
+#include "ocl_work_group.h"
+#include "ocl_simd.h"
+
+/* The pipe read function. */
+int __read_pipe_2(pipe int p, __generic void* dst);
+int __read_pipe_4(pipe int p, reserve_id_t id, uint index, void* dst);
+reserve_id_t __reserve_read_pipe(pipe int p, uint num);
+void __commit_read_pipe(pipe int p, reserve_id_t rid);
+reserve_id_t __work_group_reserve_read_pipe(pipe int p, uint num);
+void __work_group_commit_read_pipe(pipe int p, reserve_id_t rid);
+reserve_id_t __sub_group_reserve_read_pipe(pipe int p, uint num);
+void __sub_group_commit_read_pipe(pipe int p, reserve_id_t rid);
+
+/* The pipe write function. */
+int __write_pipe_2(pipe int p, __generic void* src);
+int __write_pipe_4(pipe int p, reserve_id_t id, uint index, void* src);
+reserve_id_t __reserve_write_pipe(pipe int p, uint num);
+void __commit_write_pipe(pipe int p, reserve_id_t rid);
+reserve_id_t __work_group_reserve_write_pipe(pipe int p, uint num);
+void __work_group_commit_write_pipe(pipe int p, reserve_id_t rid);
+reserve_id_t __sub_group_reserve_write_pipe(pipe int p, uint num);
+void __sub_group_commit_write_pipe(pipe int p, reserve_id_t rid);
+
+/* The reserve_id_t function. */
+bool is_valid_reserve_id(reserve_id_t rid);
+
+/* The pipe query function. */
+uint __get_pipe_num_packets(pipe int p);
+uint __get_pipe_max_packets(pipe int p);
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_printf.h b/drivers/pocl-gen7/lib/beignet/include/ocl_printf.h
new file mode 100644
index 0000000..27cef27
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_printf.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_PRINTF_H__
+#define __OCL_PRINTF_H__
+
+#include "ocl_types.h"
+
+/* The printf function. */
+/* From LLVM 3.4, c string are all in constant address space */
+#if 100*__clang_major__ + __clang_minor__ < 304
+int __gen_ocl_printf_stub(const char * format, ...);
+int __gen_ocl_puts_stub(const char * format);
+#else
+int __gen_ocl_printf_stub(constant char * format, ...);
+int __gen_ocl_puts_stub(constant char * format);
+#endif
+#define printf __gen_ocl_printf_stub
+#define puts __gen_ocl_puts_stub
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_relational.h b/drivers/pocl-gen7/lib/beignet/include/ocl_relational.h
new file mode 100644
index 0000000..f035747
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_relational.h
@@ -0,0 +1,677 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_RELATIONAL_H__
+#define __OCL_RELATIONAL_H__
+
+#include "ocl_types.h"
+#include "ocl_as.h"
+
+OVERLOADABLE int isequal(float x, float y);
+OVERLOADABLE int isnotequal(float x, float y);
+OVERLOADABLE int isgreater(float x, float y);
+OVERLOADABLE int isgreaterequal(float x, float y);
+OVERLOADABLE int isless(float x, float y);
+OVERLOADABLE int islessequal(float x, float y);
+OVERLOADABLE int islessgreater(float x, float y);
+
+OVERLOADABLE int isfinite(float x);
+OVERLOADABLE int isinf(float x);
+OVERLOADABLE int isnan(float x);
+OVERLOADABLE int isnormal(float x);
+
+OVERLOADABLE int isordered(float x, float y);
+OVERLOADABLE int isunordered(float x, float y);
+OVERLOADABLE int signbit(float x);
+
+// Half half version.
+OVERLOADABLE int isequal(half x, half y);
+OVERLOADABLE int isnotequal(half x, half y);
+OVERLOADABLE int isgreater(half x, half y);
+OVERLOADABLE int isgreaterequal(half x, half y);
+OVERLOADABLE int isless(half x, half y);
+OVERLOADABLE int islessequal(half x, half y);
+OVERLOADABLE int islessgreater(half x, half y);
+
+OVERLOADABLE int isfinite(half x);
+OVERLOADABLE int isinf(half x);
+OVERLOADABLE int isnan(half x);
+OVERLOADABLE int isnormal(half x);
+
+OVERLOADABLE int isordered(half x, half y);
+OVERLOADABLE int isunordered(half x, half y);
+OVERLOADABLE int signbit(half x);
+
+OVERLOADABLE int isequal(double x, double y);
+OVERLOADABLE int isnotequal(double x, double y);
+OVERLOADABLE int isgreater(double x, double y);
+OVERLOADABLE int isgreaterequal(double x, double y);
+OVERLOADABLE int isless(double x, double y);
+OVERLOADABLE int islessequal(double x, double y);
+OVERLOADABLE int islessgreater(double x, double y);
+
+OVERLOADABLE int isfinite(double x);
+OVERLOADABLE int isinf(double x);
+OVERLOADABLE int isnan(double x);
+OVERLOADABLE int isnormal(double x);
+
+OVERLOADABLE int isordered(double x, double y);
+OVERLOADABLE int isunordered(double x, double y);
+OVERLOADABLE int signbit(double x);
+
+// any
+#define DEC1(type) OVERLOADABLE int any(type a);
+#define DEC2(type) OVERLOADABLE int any(type a);
+#define DEC3(type) OVERLOADABLE int any(type a);
+#define DEC4(type) OVERLOADABLE int any(type a);
+#define DEC8(type) OVERLOADABLE int any(type a);
+#define DEC16(type) OVERLOADABLE int any(type a);
+DEC1(char);
+DEC1(short);
+DEC1(int);
+DEC1(long);
+#define DEC(n) DEC##n(char##n); DEC##n(short##n); DEC##n(int##n); DEC##n(long##n);
+DEC(2);
+DEC(3);
+DEC(4);
+DEC(8);
+DEC(16);
+#undef DEC
+#undef DEC1
+#undef DEC2
+#undef DEC3
+#undef DEC4
+#undef DEC8
+#undef DEC16
+
+// all
+#define DEC1(type) OVERLOADABLE int all(type a);
+#define DEC2(type) OVERLOADABLE int all(type a);
+#define DEC3(type) OVERLOADABLE int all(type a);
+#define DEC4(type) OVERLOADABLE int all(type a);
+#define DEC8(type) OVERLOADABLE int all(type a);
+#define DEC16(type) OVERLOADABLE int all(type a);
+DEC1(char)
+DEC1(short)
+DEC1(int)
+DEC1(long)
+#define DEC(n) DEC##n(char##n) DEC##n(short##n) DEC##n(int##n) DEC##n(long##n)
+DEC(2)
+DEC(3)
+DEC(4)
+DEC(8)
+DEC(16)
+#undef DEC
+#undef DEC1
+#undef DEC2
+#undef DEC3
+#undef DEC4
+#undef DEC8
+#undef DEC16
+
+#define DEF(type) OVERLOADABLE type bitselect(type a, type b, type c);
+DEF(char) DEF(uchar) DEF(short) DEF(ushort) DEF(int) DEF(uint)
+DEF(long) DEF(ulong)
+#undef DEF
+OVERLOADABLE float bitselect(float a, float b, float c);
+OVERLOADABLE half bitselect(half a, half b, half c);
+OVERLOADABLE double bitselect(double a, double b, double c);
+
+
+#define DEF(TYPE1, TYPE2) \
+OVERLOADABLE TYPE1 select(TYPE1 src0, TYPE1 src1, TYPE2 cond);
+DEF(char, char)
+DEF(char, uchar)
+DEF(uchar, char)
+DEF(uchar, uchar)
+DEF(short, short)
+DEF(short, ushort)
+DEF(ushort, short)
+DEF(ushort, ushort)
+DEF(int, int)
+DEF(int, uint)
+DEF(uint, int)
+DEF(uint, uint)
+DEF(long, long)
+DEF(long, ulong)
+DEF(ulong, long)
+DEF(ulong, ulong)
+DEF(float, int)
+DEF(float, uint)
+DEF(half, short)
+DEF(half, ushort)
+#undef DEF
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//relational builtin functions
+//intn isequal (floatn x, floatn y)
+
+OVERLOADABLE int2 isequal (float2 param0, float2 param1);
+OVERLOADABLE int3 isequal (float3 param0, float3 param1);
+OVERLOADABLE int4 isequal (float4 param0, float4 param1);
+OVERLOADABLE int8 isequal (float8 param0, float8 param1);
+OVERLOADABLE int16 isequal (float16 param0, float16 param1);
+
+//shortn isequal (halfn x, halfn y)
+
+OVERLOADABLE short2 isequal (half2 param0, half2 param1);
+OVERLOADABLE short3 isequal (half3 param0, half3 param1);
+OVERLOADABLE short4 isequal (half4 param0, half4 param1);
+OVERLOADABLE short8 isequal (half8 param0, half8 param1);
+OVERLOADABLE short16 isequal (half16 param0, half16 param1);
+
+//longn isequal (doublen x, doublen y)
+
+OVERLOADABLE long2 isequal (double2 param0, double2 param1);
+OVERLOADABLE long3 isequal (double3 param0, double3 param1);
+OVERLOADABLE long4 isequal (double4 param0, double4 param1);
+OVERLOADABLE long8 isequal (double8 param0, double8 param1);
+OVERLOADABLE long16 isequal (double16 param0, double16 param1);
+
+//intn isnotequal (floatn x, floatn y)
+
+OVERLOADABLE int2 isnotequal (float2 param0, float2 param1);
+OVERLOADABLE int3 isnotequal (float3 param0, float3 param1);
+OVERLOADABLE int4 isnotequal (float4 param0, float4 param1);
+OVERLOADABLE int8 isnotequal (float8 param0, float8 param1);
+OVERLOADABLE int16 isnotequal (float16 param0, float16 param1);
+
+//shortn isnotequal (halfn x, halfn y)
+
+OVERLOADABLE short2 isnotequal (half2 param0, half2 param1);
+OVERLOADABLE short3 isnotequal (half3 param0, half3 param1);
+OVERLOADABLE short4 isnotequal (half4 param0, half4 param1);
+OVERLOADABLE short8 isnotequal (half8 param0, half8 param1);
+OVERLOADABLE short16 isnotequal (half16 param0, half16 param1);
+
+//longn isnotequal (doublen x, doublen y)
+
+OVERLOADABLE long2 isnotequal (double2 param0, double2 param1);
+OVERLOADABLE long3 isnotequal (double3 param0, double3 param1);
+OVERLOADABLE long4 isnotequal (double4 param0, double4 param1);
+OVERLOADABLE long8 isnotequal (double8 param0, double8 param1);
+OVERLOADABLE long16 isnotequal (double16 param0, double16 param1);
+
+//intn isgreater (floatn x, floatn y)
+
+OVERLOADABLE int2 isgreater (float2 param0, float2 param1);
+OVERLOADABLE int3 isgreater (float3 param0, float3 param1);
+OVERLOADABLE int4 isgreater (float4 param0, float4 param1);
+OVERLOADABLE int8 isgreater (float8 param0, float8 param1);
+OVERLOADABLE int16 isgreater (float16 param0, float16 param1);
+
+//shortn isgreater (halfn x, halfn y)
+
+OVERLOADABLE short2 isgreater (half2 param0, half2 param1);
+OVERLOADABLE short3 isgreater (half3 param0, half3 param1);
+OVERLOADABLE short4 isgreater (half4 param0, half4 param1);
+OVERLOADABLE short8 isgreater (half8 param0, half8 param1);
+OVERLOADABLE short16 isgreater (half16 param0, half16 param1);
+
+//longn isgreater (doublen x, doublen y)
+
+OVERLOADABLE long2 isgreater (double2 param0, double2 param1);
+OVERLOADABLE long3 isgreater (double3 param0, double3 param1);
+OVERLOADABLE long4 isgreater (double4 param0, double4 param1);
+OVERLOADABLE long8 isgreater (double8 param0, double8 param1);
+OVERLOADABLE long16 isgreater (double16 param0, double16 param1);
+
+//intn isgreaterequal (floatn x, floatn y)
+
+OVERLOADABLE int2 isgreaterequal (float2 param0, float2 param1);
+OVERLOADABLE int3 isgreaterequal (float3 param0, float3 param1);
+OVERLOADABLE int4 isgreaterequal (float4 param0, float4 param1);
+OVERLOADABLE int8 isgreaterequal (float8 param0, float8 param1);
+OVERLOADABLE int16 isgreaterequal (float16 param0, float16 param1);
+
+//shortn isgreaterequal (halfn x, halfn y)
+
+OVERLOADABLE short2 isgreaterequal (half2 param0, half2 param1);
+OVERLOADABLE short3 isgreaterequal (half3 param0, half3 param1);
+OVERLOADABLE short4 isgreaterequal (half4 param0, half4 param1);
+OVERLOADABLE short8 isgreaterequal (half8 param0, half8 param1);
+OVERLOADABLE short16 isgreaterequal (half16 param0, half16 param1);
+
+//longn isgreaterequal (doublen x, doublen y)
+
+OVERLOADABLE long2 isgreaterequal (double2 param0, double2 param1);
+OVERLOADABLE long3 isgreaterequal (double3 param0, double3 param1);
+OVERLOADABLE long4 isgreaterequal (double4 param0, double4 param1);
+OVERLOADABLE long8 isgreaterequal (double8 param0, double8 param1);
+OVERLOADABLE long16 isgreaterequal (double16 param0, double16 param1);
+
+//intn isless (floatn x, floatn y)
+
+OVERLOADABLE int2 isless (float2 param0, float2 param1);
+OVERLOADABLE int3 isless (float3 param0, float3 param1);
+OVERLOADABLE int4 isless (float4 param0, float4 param1);
+OVERLOADABLE int8 isless (float8 param0, float8 param1);
+OVERLOADABLE int16 isless (float16 param0, float16 param1);
+
+//shortn isless (halfn x, halfn y)
+
+OVERLOADABLE short2 isless (half2 param0, half2 param1);
+OVERLOADABLE short3 isless (half3 param0, half3 param1);
+OVERLOADABLE short4 isless (half4 param0, half4 param1);
+OVERLOADABLE short8 isless (half8 param0, half8 param1);
+OVERLOADABLE short16 isless (half16 param0, half16 param1);
+
+//longn isless (doublen x, doublen y)
+
+OVERLOADABLE long2 isless (double2 param0, double2 param1);
+OVERLOADABLE long3 isless (double3 param0, double3 param1);
+OVERLOADABLE long4 isless (double4 param0, double4 param1);
+OVERLOADABLE long8 isless (double8 param0, double8 param1);
+OVERLOADABLE long16 isless (double16 param0, double16 param1);
+
+//intn islessequal (floatn x, floatn y)
+
+OVERLOADABLE int2 islessequal (float2 param0, float2 param1);
+OVERLOADABLE int3 islessequal (float3 param0, float3 param1);
+OVERLOADABLE int4 islessequal (float4 param0, float4 param1);
+OVERLOADABLE int8 islessequal (float8 param0, float8 param1);
+OVERLOADABLE int16 islessequal (float16 param0, float16 param1);
+
+//shortn islessequal (halfn x, halfn y)
+
+OVERLOADABLE short2 islessequal (half2 param0, half2 param1);
+OVERLOADABLE short3 islessequal (half3 param0, half3 param1);
+OVERLOADABLE short4 islessequal (half4 param0, half4 param1);
+OVERLOADABLE short8 islessequal (half8 param0, half8 param1);
+OVERLOADABLE short16 islessequal (half16 param0, half16 param1);
+
+//longn islessequal (doublen x, doublen y)
+
+OVERLOADABLE long2 islessequal (double2 param0, double2 param1);
+OVERLOADABLE long3 islessequal (double3 param0, double3 param1);
+OVERLOADABLE long4 islessequal (double4 param0, double4 param1);
+OVERLOADABLE long8 islessequal (double8 param0, double8 param1);
+OVERLOADABLE long16 islessequal (double16 param0, double16 param1);
+
+//intn islessgreater (floatn x, floatn y)
+
+OVERLOADABLE int2 islessgreater (float2 param0, float2 param1);
+OVERLOADABLE int3 islessgreater (float3 param0, float3 param1);
+OVERLOADABLE int4 islessgreater (float4 param0, float4 param1);
+OVERLOADABLE int8 islessgreater (float8 param0, float8 param1);
+OVERLOADABLE int16 islessgreater (float16 param0, float16 param1);
+
+//shortn islessgreater (halfn x, halfn y)
+
+OVERLOADABLE short2 islessgreater (half2 param0, half2 param1);
+OVERLOADABLE short3 islessgreater (half3 param0, half3 param1);
+OVERLOADABLE short4 islessgreater (half4 param0, half4 param1);
+OVERLOADABLE short8 islessgreater (half8 param0, half8 param1);
+OVERLOADABLE short16 islessgreater (half16 param0, half16 param1);
+
+//longn islessgreater (doublen x, doublen y)
+
+OVERLOADABLE long2 islessgreater (double2 param0, double2 param1);
+OVERLOADABLE long3 islessgreater (double3 param0, double3 param1);
+OVERLOADABLE long4 islessgreater (double4 param0, double4 param1);
+OVERLOADABLE long8 islessgreater (double8 param0, double8 param1);
+OVERLOADABLE long16 islessgreater (double16 param0, double16 param1);
+
+//intn isfinite (floatn)
+
+OVERLOADABLE int2 isfinite (float2 param0);
+OVERLOADABLE int3 isfinite (float3 param0);
+OVERLOADABLE int4 isfinite (float4 param0);
+OVERLOADABLE int8 isfinite (float8 param0);
+OVERLOADABLE int16 isfinite (float16 param0);
+
+//shortn isfinite (halfn)
+
+OVERLOADABLE short2 isfinite (half2 param0);
+OVERLOADABLE short3 isfinite (half3 param0);
+OVERLOADABLE short4 isfinite (half4 param0);
+OVERLOADABLE short8 isfinite (half8 param0);
+OVERLOADABLE short16 isfinite (half16 param0);
+
+//longn isfinite (doublen)
+
+OVERLOADABLE long2 isfinite (double2 param0);
+OVERLOADABLE long3 isfinite (double3 param0);
+OVERLOADABLE long4 isfinite (double4 param0);
+OVERLOADABLE long8 isfinite (double8 param0);
+OVERLOADABLE long16 isfinite (double16 param0);
+
+//intn isinf (floatn)
+
+OVERLOADABLE int2 isinf (float2 param0);
+OVERLOADABLE int3 isinf (float3 param0);
+OVERLOADABLE int4 isinf (float4 param0);
+OVERLOADABLE int8 isinf (float8 param0);
+OVERLOADABLE int16 isinf (float16 param0);
+
+//shortn isinf (halfn)
+
+OVERLOADABLE short2 isinf (half2 param0);
+OVERLOADABLE short3 isinf (half3 param0);
+OVERLOADABLE short4 isinf (half4 param0);
+OVERLOADABLE short8 isinf (half8 param0);
+OVERLOADABLE short16 isinf (half16 param0);
+
+//longn isinf (doublen)
+
+OVERLOADABLE long2 isinf (double2 param0);
+OVERLOADABLE long3 isinf (double3 param0);
+OVERLOADABLE long4 isinf (double4 param0);
+OVERLOADABLE long8 isinf (double8 param0);
+OVERLOADABLE long16 isinf (double16 param0);
+
+//intn isnan (floatn)
+
+OVERLOADABLE int2 isnan (float2 param0);
+OVERLOADABLE int3 isnan (float3 param0);
+OVERLOADABLE int4 isnan (float4 param0);
+OVERLOADABLE int8 isnan (float8 param0);
+OVERLOADABLE int16 isnan (float16 param0);
+
+//shortn isnan (halfn)
+
+OVERLOADABLE short2 isnan (half2 param0);
+OVERLOADABLE short3 isnan (half3 param0);
+OVERLOADABLE short4 isnan (half4 param0);
+OVERLOADABLE short8 isnan (half8 param0);
+OVERLOADABLE short16 isnan (half16 param0);
+
+//longn isnan (doublen)
+
+OVERLOADABLE long2 isnan (double2 param0);
+OVERLOADABLE long3 isnan (double3 param0);
+OVERLOADABLE long4 isnan (double4 param0);
+OVERLOADABLE long8 isnan (double8 param0);
+OVERLOADABLE long16 isnan (double16 param0);
+
+//intn isnormal (floatn)
+
+OVERLOADABLE int2 isnormal (float2 param0);
+OVERLOADABLE int3 isnormal (float3 param0);
+OVERLOADABLE int4 isnormal (float4 param0);
+OVERLOADABLE int8 isnormal (float8 param0);
+OVERLOADABLE int16 isnormal (float16 param0);
+
+//shortn isnormal (halfn)
+
+OVERLOADABLE short2 isnormal (half2 param0);
+OVERLOADABLE short3 isnormal (half3 param0);
+OVERLOADABLE short4 isnormal (half4 param0);
+OVERLOADABLE short8 isnormal (half8 param0);
+OVERLOADABLE short16 isnormal (half16 param0);
+
+//longn isnormal (doublen)
+
+OVERLOADABLE long2 isnormal (double2 param0);
+OVERLOADABLE long3 isnormal (double3 param0);
+OVERLOADABLE long4 isnormal (double4 param0);
+OVERLOADABLE long8 isnormal (double8 param0);
+OVERLOADABLE long16 isnormal (double16 param0);
+
+//intn isordered (floatn x, floatn y)
+
+OVERLOADABLE int2 isordered (float2 param0, float2 param1);
+OVERLOADABLE int3 isordered (float3 param0, float3 param1);
+OVERLOADABLE int4 isordered (float4 param0, float4 param1);
+OVERLOADABLE int8 isordered (float8 param0, float8 param1);
+OVERLOADABLE int16 isordered (float16 param0, float16 param1);
+
+//shortn isordered (halfn x, halfn y)
+
+OVERLOADABLE short2 isordered (half2 param0, half2 param1);
+OVERLOADABLE short3 isordered (half3 param0, half3 param1);
+OVERLOADABLE short4 isordered (half4 param0, half4 param1);
+OVERLOADABLE short8 isordered (half8 param0, half8 param1);
+OVERLOADABLE short16 isordered (half16 param0, half16 param1);
+
+//longn isordered (doublen x, doublen y)
+
+OVERLOADABLE long2 isordered (double2 param0, double2 param1);
+OVERLOADABLE long3 isordered (double3 param0, double3 param1);
+OVERLOADABLE long4 isordered (double4 param0, double4 param1);
+OVERLOADABLE long8 isordered (double8 param0, double8 param1);
+OVERLOADABLE long16 isordered (double16 param0, double16 param1);
+
+//intn isunordered (floatn x, floatn y)
+
+OVERLOADABLE int2 isunordered (float2 param0, float2 param1);
+OVERLOADABLE int3 isunordered (float3 param0, float3 param1);
+OVERLOADABLE int4 isunordered (float4 param0, float4 param1);
+OVERLOADABLE int8 isunordered (float8 param0, float8 param1);
+OVERLOADABLE int16 isunordered (float16 param0, float16 param1);
+
+//shortn isunordered (halfn x, halfn y)
+
+OVERLOADABLE short2 isunordered (half2 param0, half2 param1);
+OVERLOADABLE short3 isunordered (half3 param0, half3 param1);
+OVERLOADABLE short4 isunordered (half4 param0, half4 param1);
+OVERLOADABLE short8 isunordered (half8 param0, half8 param1);
+OVERLOADABLE short16 isunordered (half16 param0, half16 param1);
+
+//longn isunordered (doublen x, doublen y)
+
+OVERLOADABLE long2 isunordered (double2 param0, double2 param1);
+OVERLOADABLE long3 isunordered (double3 param0, double3 param1);
+OVERLOADABLE long4 isunordered (double4 param0, double4 param1);
+OVERLOADABLE long8 isunordered (double8 param0, double8 param1);
+OVERLOADABLE long16 isunordered (double16 param0, double16 param1);
+
+//intn signbit (floatn)
+
+OVERLOADABLE int2 signbit (float2 param0);
+OVERLOADABLE int3 signbit (float3 param0);
+OVERLOADABLE int4 signbit (float4 param0);
+OVERLOADABLE int8 signbit (float8 param0);
+OVERLOADABLE int16 signbit (float16 param0);
+
+//shortn signbit (halfn)
+
+OVERLOADABLE short2 signbit (half2 param0);
+OVERLOADABLE short3 signbit (half3 param0);
+OVERLOADABLE short4 signbit (half4 param0);
+OVERLOADABLE short8 signbit (half8 param0);
+OVERLOADABLE short16 signbit (half16 param0);
+
+//longn signbit (doublen)
+
+OVERLOADABLE long2 signbit (double2 param0);
+OVERLOADABLE long3 signbit (double3 param0);
+OVERLOADABLE long4 signbit (double4 param0);
+OVERLOADABLE long8 signbit (double8 param0);
+OVERLOADABLE long16 signbit (double16 param0);
+
+//int any (igentype x)
+
+
+//int all (igentype x)
+
+
+//gentype bitselect (gentype a, gentype b, gentype c)
+
+OVERLOADABLE char2 bitselect (char2 param0, char2 param1, char2 param2);
+OVERLOADABLE char3 bitselect (char3 param0, char3 param1, char3 param2);
+OVERLOADABLE char4 bitselect (char4 param0, char4 param1, char4 param2);
+OVERLOADABLE char8 bitselect (char8 param0, char8 param1, char8 param2);
+OVERLOADABLE char16 bitselect (char16 param0, char16 param1, char16 param2);
+OVERLOADABLE short2 bitselect (short2 param0, short2 param1, short2 param2);
+OVERLOADABLE short3 bitselect (short3 param0, short3 param1, short3 param2);
+OVERLOADABLE short4 bitselect (short4 param0, short4 param1, short4 param2);
+OVERLOADABLE short8 bitselect (short8 param0, short8 param1, short8 param2);
+OVERLOADABLE short16 bitselect (short16 param0, short16 param1, short16 param2);
+OVERLOADABLE int2 bitselect (int2 param0, int2 param1, int2 param2);
+OVERLOADABLE int3 bitselect (int3 param0, int3 param1, int3 param2);
+OVERLOADABLE int4 bitselect (int4 param0, int4 param1, int4 param2);
+OVERLOADABLE int8 bitselect (int8 param0, int8 param1, int8 param2);
+OVERLOADABLE int16 bitselect (int16 param0, int16 param1, int16 param2);
+OVERLOADABLE long2 bitselect (long2 param0, long2 param1, long2 param2);
+OVERLOADABLE long3 bitselect (long3 param0, long3 param1, long3 param2);
+OVERLOADABLE long4 bitselect (long4 param0, long4 param1, long4 param2);
+OVERLOADABLE long8 bitselect (long8 param0, long8 param1, long8 param2);
+OVERLOADABLE long16 bitselect (long16 param0, long16 param1, long16 param2);
+OVERLOADABLE uchar2 bitselect (uchar2 param0, uchar2 param1, uchar2 param2);
+OVERLOADABLE uchar3 bitselect (uchar3 param0, uchar3 param1, uchar3 param2);
+OVERLOADABLE uchar4 bitselect (uchar4 param0, uchar4 param1, uchar4 param2);
+OVERLOADABLE uchar8 bitselect (uchar8 param0, uchar8 param1, uchar8 param2);
+OVERLOADABLE uchar16 bitselect (uchar16 param0, uchar16 param1, uchar16 param2);
+OVERLOADABLE ushort2 bitselect (ushort2 param0, ushort2 param1, ushort2 param2);
+OVERLOADABLE ushort3 bitselect (ushort3 param0, ushort3 param1, ushort3 param2);
+OVERLOADABLE ushort4 bitselect (ushort4 param0, ushort4 param1, ushort4 param2);
+OVERLOADABLE ushort8 bitselect (ushort8 param0, ushort8 param1, ushort8 param2);
+OVERLOADABLE ushort16 bitselect (ushort16 param0, ushort16 param1, ushort16 param2);
+OVERLOADABLE uint2 bitselect (uint2 param0, uint2 param1, uint2 param2);
+OVERLOADABLE uint3 bitselect (uint3 param0, uint3 param1, uint3 param2);
+OVERLOADABLE uint4 bitselect (uint4 param0, uint4 param1, uint4 param2);
+OVERLOADABLE uint8 bitselect (uint8 param0, uint8 param1, uint8 param2);
+OVERLOADABLE uint16 bitselect (uint16 param0, uint16 param1, uint16 param2);
+OVERLOADABLE ulong2 bitselect (ulong2 param0, ulong2 param1, ulong2 param2);
+OVERLOADABLE ulong3 bitselect (ulong3 param0, ulong3 param1, ulong3 param2);
+OVERLOADABLE ulong4 bitselect (ulong4 param0, ulong4 param1, ulong4 param2);
+OVERLOADABLE ulong8 bitselect (ulong8 param0, ulong8 param1, ulong8 param2);
+OVERLOADABLE ulong16 bitselect (ulong16 param0, ulong16 param1, ulong16 param2);
+OVERLOADABLE float2 bitselect (float2 param0, float2 param1, float2 param2);
+OVERLOADABLE float3 bitselect (float3 param0, float3 param1, float3 param2);
+OVERLOADABLE float4 bitselect (float4 param0, float4 param1, float4 param2);
+OVERLOADABLE float8 bitselect (float8 param0, float8 param1, float8 param2);
+OVERLOADABLE float16 bitselect (float16 param0, float16 param1, float16 param2);
+OVERLOADABLE double2 bitselect (double2 param0, double2 param1, double2 param2);
+OVERLOADABLE double3 bitselect (double3 param0, double3 param1, double3 param2);
+OVERLOADABLE double4 bitselect (double4 param0, double4 param1, double4 param2);
+OVERLOADABLE double8 bitselect (double8 param0, double8 param1, double8 param2);
+OVERLOADABLE double16 bitselect (double16 param0, double16 param1, double16 param2);
+OVERLOADABLE half2 bitselect (half2 param0, half2 param1, half2 param2);
+OVERLOADABLE half3 bitselect (half3 param0, half3 param1, half3 param2);
+OVERLOADABLE half4 bitselect (half4 param0, half4 param1, half4 param2);
+OVERLOADABLE half8 bitselect (half8 param0, half8 param1, half8 param2);
+OVERLOADABLE half16 bitselect (half16 param0, half16 param1, half16 param2);
+
+//gentype select (gentype a, gentype b, igentype c)
+
+OVERLOADABLE char2 select (char2 param0, char2 param1, char2 param2);
+OVERLOADABLE char3 select (char3 param0, char3 param1, char3 param2);
+OVERLOADABLE char4 select (char4 param0, char4 param1, char4 param2);
+OVERLOADABLE char8 select (char8 param0, char8 param1, char8 param2);
+OVERLOADABLE char16 select (char16 param0, char16 param1, char16 param2);
+OVERLOADABLE short2 select (short2 param0, short2 param1, short2 param2);
+OVERLOADABLE short3 select (short3 param0, short3 param1, short3 param2);
+OVERLOADABLE short4 select (short4 param0, short4 param1, short4 param2);
+OVERLOADABLE short8 select (short8 param0, short8 param1, short8 param2);
+OVERLOADABLE short16 select (short16 param0, short16 param1, short16 param2);
+OVERLOADABLE int2 select (int2 param0, int2 param1, int2 param2);
+OVERLOADABLE int3 select (int3 param0, int3 param1, int3 param2);
+OVERLOADABLE int4 select (int4 param0, int4 param1, int4 param2);
+OVERLOADABLE int8 select (int8 param0, int8 param1, int8 param2);
+OVERLOADABLE int16 select (int16 param0, int16 param1, int16 param2);
+OVERLOADABLE long2 select (long2 param0, long2 param1, long2 param2);
+OVERLOADABLE long3 select (long3 param0, long3 param1, long3 param2);
+OVERLOADABLE long4 select (long4 param0, long4 param1, long4 param2);
+OVERLOADABLE long8 select (long8 param0, long8 param1, long8 param2);
+OVERLOADABLE long16 select (long16 param0, long16 param1, long16 param2);
+OVERLOADABLE uchar2 select (uchar2 param0, uchar2 param1, char2 param2);
+OVERLOADABLE uchar3 select (uchar3 param0, uchar3 param1, char3 param2);
+OVERLOADABLE uchar4 select (uchar4 param0, uchar4 param1, char4 param2);
+OVERLOADABLE uchar8 select (uchar8 param0, uchar8 param1, char8 param2);
+OVERLOADABLE uchar16 select (uchar16 param0, uchar16 param1, char16 param2);
+OVERLOADABLE ushort2 select (ushort2 param0, ushort2 param1, short2 param2);
+OVERLOADABLE ushort3 select (ushort3 param0, ushort3 param1, short3 param2);
+OVERLOADABLE ushort4 select (ushort4 param0, ushort4 param1, short4 param2);
+OVERLOADABLE ushort8 select (ushort8 param0, ushort8 param1, short8 param2);
+OVERLOADABLE ushort16 select (ushort16 param0, ushort16 param1, short16 param2);
+OVERLOADABLE uint2 select (uint2 param0, uint2 param1, int2 param2);
+OVERLOADABLE uint3 select (uint3 param0, uint3 param1, int3 param2);
+OVERLOADABLE uint4 select (uint4 param0, uint4 param1, int4 param2);
+OVERLOADABLE uint8 select (uint8 param0, uint8 param1, int8 param2);
+OVERLOADABLE uint16 select (uint16 param0, uint16 param1, int16 param2);
+OVERLOADABLE ulong2 select (ulong2 param0, ulong2 param1, long2 param2);
+OVERLOADABLE ulong3 select (ulong3 param0, ulong3 param1, long3 param2);
+OVERLOADABLE ulong4 select (ulong4 param0, ulong4 param1, long4 param2);
+OVERLOADABLE ulong8 select (ulong8 param0, ulong8 param1, long8 param2);
+OVERLOADABLE ulong16 select (ulong16 param0, ulong16 param1, long16 param2);
+OVERLOADABLE float2 select (float2 param0, float2 param1, int2 param2);
+OVERLOADABLE float3 select (float3 param0, float3 param1, int3 param2);
+OVERLOADABLE float4 select (float4 param0, float4 param1, int4 param2);
+OVERLOADABLE float8 select (float8 param0, float8 param1, int8 param2);
+OVERLOADABLE float16 select (float16 param0, float16 param1, int16 param2);
+OVERLOADABLE double2 select (double2 param0, double2 param1, long2 param2);
+OVERLOADABLE double3 select (double3 param0, double3 param1, long3 param2);
+OVERLOADABLE double4 select (double4 param0, double4 param1, long4 param2);
+OVERLOADABLE double8 select (double8 param0, double8 param1, long8 param2);
+OVERLOADABLE double16 select (double16 param0, double16 param1, long16 param2);
+OVERLOADABLE half2 select (half2 param0, half2 param1, short2 param2);
+OVERLOADABLE half3 select (half3 param0, half3 param1, short3 param2);
+OVERLOADABLE half4 select (half4 param0, half4 param1, short4 param2);
+OVERLOADABLE half8 select (half8 param0, half8 param1, short8 param2);
+OVERLOADABLE half16 select (half16 param0, half16 param1, short16 param2);
+
+//gentype select (gentype a, gentype b, ugentype c)
+
+OVERLOADABLE char2 select (char2 param0, char2 param1, uchar2 param2);
+OVERLOADABLE char3 select (char3 param0, char3 param1, uchar3 param2);
+OVERLOADABLE char4 select (char4 param0, char4 param1, uchar4 param2);
+OVERLOADABLE char8 select (char8 param0, char8 param1, uchar8 param2);
+OVERLOADABLE char16 select (char16 param0, char16 param1, uchar16 param2);
+OVERLOADABLE short2 select (short2 param0, short2 param1, ushort2 param2);
+OVERLOADABLE short3 select (short3 param0, short3 param1, ushort3 param2);
+OVERLOADABLE short4 select (short4 param0, short4 param1, ushort4 param2);
+OVERLOADABLE short8 select (short8 param0, short8 param1, ushort8 param2);
+OVERLOADABLE short16 select (short16 param0, short16 param1, ushort16 param2);
+OVERLOADABLE int2 select (int2 param0, int2 param1, uint2 param2);
+OVERLOADABLE int3 select (int3 param0, int3 param1, uint3 param2);
+OVERLOADABLE int4 select (int4 param0, int4 param1, uint4 param2);
+OVERLOADABLE int8 select (int8 param0, int8 param1, uint8 param2);
+OVERLOADABLE int16 select (int16 param0, int16 param1, uint16 param2);
+OVERLOADABLE long2 select (long2 param0, long2 param1, ulong2 param2);
+OVERLOADABLE long3 select (long3 param0, long3 param1, ulong3 param2);
+OVERLOADABLE long4 select (long4 param0, long4 param1, ulong4 param2);
+OVERLOADABLE long8 select (long8 param0, long8 param1, ulong8 param2);
+OVERLOADABLE long16 select (long16 param0, long16 param1, ulong16 param2);
+OVERLOADABLE uchar2 select (uchar2 param0, uchar2 param1, uchar2 param2);
+OVERLOADABLE uchar3 select (uchar3 param0, uchar3 param1, uchar3 param2);
+OVERLOADABLE uchar4 select (uchar4 param0, uchar4 param1, uchar4 param2);
+OVERLOADABLE uchar8 select (uchar8 param0, uchar8 param1, uchar8 param2);
+OVERLOADABLE uchar16 select (uchar16 param0, uchar16 param1, uchar16 param2);
+OVERLOADABLE ushort2 select (ushort2 param0, ushort2 param1, ushort2 param2);
+OVERLOADABLE ushort3 select (ushort3 param0, ushort3 param1, ushort3 param2);
+OVERLOADABLE ushort4 select (ushort4 param0, ushort4 param1, ushort4 param2);
+OVERLOADABLE ushort8 select (ushort8 param0, ushort8 param1, ushort8 param2);
+OVERLOADABLE ushort16 select (ushort16 param0, ushort16 param1, ushort16 param2);
+OVERLOADABLE uint2 select (uint2 param0, uint2 param1, uint2 param2);
+OVERLOADABLE uint3 select (uint3 param0, uint3 param1, uint3 param2);
+OVERLOADABLE uint4 select (uint4 param0, uint4 param1, uint4 param2);
+OVERLOADABLE uint8 select (uint8 param0, uint8 param1, uint8 param2);
+OVERLOADABLE uint16 select (uint16 param0, uint16 param1, uint16 param2);
+OVERLOADABLE ulong2 select (ulong2 param0, ulong2 param1, ulong2 param2);
+OVERLOADABLE ulong3 select (ulong3 param0, ulong3 param1, ulong3 param2);
+OVERLOADABLE ulong4 select (ulong4 param0, ulong4 param1, ulong4 param2);
+OVERLOADABLE ulong8 select (ulong8 param0, ulong8 param1, ulong8 param2);
+OVERLOADABLE ulong16 select (ulong16 param0, ulong16 param1, ulong16 param2);
+OVERLOADABLE float2 select (float2 param0, float2 param1, uint2 param2);
+OVERLOADABLE float3 select (float3 param0, float3 param1, uint3 param2);
+OVERLOADABLE float4 select (float4 param0, float4 param1, uint4 param2);
+OVERLOADABLE float8 select (float8 param0, float8 param1, uint8 param2);
+OVERLOADABLE float16 select (float16 param0, float16 param1, uint16 param2);
+OVERLOADABLE double2 select (double2 param0, double2 param1, ulong2 param2);
+OVERLOADABLE double3 select (double3 param0, double3 param1, ulong3 param2);
+OVERLOADABLE double4 select (double4 param0, double4 param1, ulong4 param2);
+OVERLOADABLE double8 select (double8 param0, double8 param1, ulong8 param2);
+OVERLOADABLE double16 select (double16 param0, double16 param1, ulong16 param2);
+OVERLOADABLE half2 select (half2 param0, half2 param1, ushort2 param2);
+OVERLOADABLE half3 select (half3 param0, half3 param1, ushort3 param2);
+OVERLOADABLE half4 select (half4 param0, half4 param1, ushort4 param2);
+OVERLOADABLE half8 select (half8 param0, half8 param1, ushort8 param2);
+OVERLOADABLE half16 select (half16 param0, half16 param1, ushort16 param2);
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_simd.h b/drivers/pocl-gen7/lib/beignet/include/ocl_simd.h
new file mode 100644
index 0000000..9cb56d2
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_simd.h
@@ -0,0 +1,386 @@
+/*
+ * Copyright © 2015 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_SIMD_H__
+#define __OCL_SIMD_H__
+
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// SIMD level function
+/////////////////////////////////////////////////////////////////////////////
+int sub_group_any(int);
+int sub_group_all(int);
+
+uint get_simd_size(void);
+
+uint get_sub_group_size(void);
+uint get_max_sub_group_size(void);
+uint get_num_sub_groups(void);
+uint get_sub_group_id(void);
+uint get_sub_group_local_id(void);
+
+/* broadcast */
+OVERLOADABLE int sub_group_broadcast(int a,uint local_id);
+OVERLOADABLE uint sub_group_broadcast(uint a, uint local_id);
+OVERLOADABLE long sub_group_broadcast(long a, uint local_id);
+OVERLOADABLE ulong sub_group_broadcast(ulong a, uint local_id);
+OVERLOADABLE half sub_group_broadcast(half a, uint local_id);
+OVERLOADABLE float sub_group_broadcast(float a, uint local_id);
+OVERLOADABLE double sub_group_broadcast(double a, uint local_id);
+OVERLOADABLE short sub_group_broadcast(short a,uint local_id);
+OVERLOADABLE ushort sub_group_broadcast(ushort a, uint local_id);
+
+OVERLOADABLE short intel_sub_group_broadcast(short a, uint local_id);
+OVERLOADABLE ushort intel_sub_group_broadcast(ushort a, uint local_id);
+/* reduce add */
+OVERLOADABLE int sub_group_reduce_add(int x);
+OVERLOADABLE uint sub_group_reduce_add(uint x);
+OVERLOADABLE long sub_group_reduce_add(long x);
+OVERLOADABLE ulong sub_group_reduce_add(ulong x);
+OVERLOADABLE half sub_group_reduce_add(half x);
+OVERLOADABLE float sub_group_reduce_add(float x);
+OVERLOADABLE double sub_group_reduce_add(double x);
+OVERLOADABLE short sub_group_reduce_add(short x);
+OVERLOADABLE ushort sub_group_reduce_add(ushort x);
+OVERLOADABLE short intel_sug_group_reduce_add(short x);
+OVERLOADABLE ushort intel_sug_group_reduce_add(ushort x);
+
+/* reduce min */
+OVERLOADABLE int sub_group_reduce_min(int x);
+OVERLOADABLE uint sub_group_reduce_min(uint x);
+OVERLOADABLE long sub_group_reduce_min(long x);
+OVERLOADABLE ulong sub_group_reduce_min(ulong x);
+OVERLOADABLE half sub_group_reduce_min(half x);
+OVERLOADABLE float sub_group_reduce_min(float x);
+OVERLOADABLE double sub_group_reduce_min(double x);
+OVERLOADABLE short sub_group_reduce_min(short x);
+OVERLOADABLE ushort sub_group_reduce_min(ushort x);
+OVERLOADABLE short intel_sug_group_reduce_min(short x);
+OVERLOADABLE ushort intel_sug_group_reduce_min(ushort x);
+
+/* reduce max */
+OVERLOADABLE int sub_group_reduce_max(int x);
+OVERLOADABLE uint sub_group_reduce_max(uint x);
+OVERLOADABLE long sub_group_reduce_max(long x);
+OVERLOADABLE ulong sub_group_reduce_max(ulong x);
+OVERLOADABLE half sub_group_reduce_max(half x);
+OVERLOADABLE float sub_group_reduce_max(float x);
+OVERLOADABLE double sub_group_reduce_max(double x);
+OVERLOADABLE short sub_group_reduce_max(short x);
+OVERLOADABLE ushort sub_group_reduce_max(ushort x);
+OVERLOADABLE short intel_sug_group_reduce_max(short x);
+OVERLOADABLE ushort intel_sug_group_reduce_max(ushort x);
+
+/* scan_inclusive add */
+OVERLOADABLE int sub_group_scan_inclusive_add(int x);
+OVERLOADABLE uint sub_group_scan_inclusive_add(uint x);
+OVERLOADABLE long sub_group_scan_inclusive_add(long x);
+OVERLOADABLE ulong sub_group_scan_inclusive_add(ulong x);
+OVERLOADABLE half sub_group_scan_inclusive_add(half x);
+OVERLOADABLE float sub_group_scan_inclusive_add(float x);
+OVERLOADABLE double sub_group_scan_inclusive_add(double x);
+OVERLOADABLE short sub_group_scan_inclusive_add(short x);
+OVERLOADABLE ushort sub_group_scan_inclusive_add(ushort x);
+OVERLOADABLE short intel_sug_group_scan_inclusive_add(short x);
+OVERLOADABLE ushort intel_sug_group_scan_inclusive_add(ushort x);
+
+/* scan_inclusive min */
+OVERLOADABLE int sub_group_scan_inclusive_min(int x);
+OVERLOADABLE uint sub_group_scan_inclusive_min(uint x);
+OVERLOADABLE long sub_group_scan_inclusive_min(long x);
+OVERLOADABLE ulong sub_group_scan_inclusive_min(ulong x);
+OVERLOADABLE half sub_group_scan_inclusive_min(half x);
+OVERLOADABLE float sub_group_scan_inclusive_min(float x);
+OVERLOADABLE double sub_group_scan_inclusive_min(double x);
+OVERLOADABLE short sub_group_scan_inclusive_min(short x);
+OVERLOADABLE ushort sub_group_scan_inclusive_min(ushort x);
+OVERLOADABLE short intel_sug_group_scan_inclusive_min(short x);
+OVERLOADABLE ushort intel_sug_group_scan_inclusive_min(ushort x);
+
+/* scan_inclusive max */
+OVERLOADABLE int sub_group_scan_inclusive_max(int x);
+OVERLOADABLE uint sub_group_scan_inclusive_max(uint x);
+OVERLOADABLE long sub_group_scan_inclusive_max(long x);
+OVERLOADABLE ulong sub_group_scan_inclusive_max(ulong x);
+OVERLOADABLE half sub_group_scan_inclusive_max(half x);
+OVERLOADABLE float sub_group_scan_inclusive_max(float x);
+OVERLOADABLE double sub_group_scan_inclusive_max(double x);
+OVERLOADABLE short sub_group_scan_inclusive_max(short x);
+OVERLOADABLE ushort sub_group_scan_inclusive_max(ushort x);
+OVERLOADABLE short intel_sug_group_scan_inclusive_max(short x);
+OVERLOADABLE ushort intel_sug_group_scan_inclusive_max(ushort x);
+
+/* scan_exclusive add */
+OVERLOADABLE int sub_group_scan_exclusive_add(int x);
+OVERLOADABLE uint sub_group_scan_exclusive_add(uint x);
+OVERLOADABLE long sub_group_scan_exclusive_add(long x);
+OVERLOADABLE ulong sub_group_scan_exclusive_add(ulong x);
+OVERLOADABLE half sub_group_scan_exclusive_add(half x);
+OVERLOADABLE float sub_group_scan_exclusive_add(float x);
+OVERLOADABLE double sub_group_scan_exclusive_add(double x);
+OVERLOADABLE short sub_group_scan_exclusive_add(short x);
+OVERLOADABLE ushort sub_group_scan_exclusive_add(ushort x);
+OVERLOADABLE short intel_sub_group_scan_exclusive_add(short x);
+OVERLOADABLE ushort intel_sub_group_scan_exclusive_add(ushort x);
+
+/* scan_exclusive min */
+OVERLOADABLE int sub_group_scan_exclusive_min(int x);
+OVERLOADABLE uint sub_group_scan_exclusive_min(uint x);
+OVERLOADABLE long sub_group_scan_exclusive_min(long x);
+OVERLOADABLE ulong sub_group_scan_exclusive_min(ulong x);
+OVERLOADABLE half sub_group_scan_exclusive_min(half x);
+OVERLOADABLE float sub_group_scan_exclusive_min(float x);
+OVERLOADABLE double sub_group_scan_exclusive_min(double x);
+OVERLOADABLE short sub_group_scan_exclusive_min(short x);
+OVERLOADABLE ushort sub_group_scan_exclusive_min(ushort x);
+OVERLOADABLE short intel_sug_group_scan_exclusive_min(short x);
+OVERLOADABLE ushort intel_sug_group_scan_exclusive_min(ushort x);
+
+/* scan_exclusive max */
+OVERLOADABLE int sub_group_scan_exclusive_max(int x);
+OVERLOADABLE uint sub_group_scan_exclusive_max(uint x);
+OVERLOADABLE long sub_group_scan_exclusive_max(long x);
+OVERLOADABLE ulong sub_group_scan_exclusive_max(ulong x);
+OVERLOADABLE half sub_group_scan_exclusive_max(half x);
+OVERLOADABLE float sub_group_scan_exclusive_max(float x);
+OVERLOADABLE double sub_group_scan_exclusive_max(double x);
+OVERLOADABLE short sub_group_scan_exclusive_max(short x);
+OVERLOADABLE ushort sub_group_scan_exclusive_max(ushort x);
+OVERLOADABLE short intel_sug_group_scan_exclusive_max(short x);
+OVERLOADABLE ushort intel_sug_group_scan_exclusive_max(ushort x);
+
+/* shuffle */
+OVERLOADABLE half intel_sub_group_shuffle(half x, uint c);
+OVERLOADABLE float intel_sub_group_shuffle(float x, uint c);
+OVERLOADABLE int intel_sub_group_shuffle(int x, uint c);
+OVERLOADABLE uint intel_sub_group_shuffle(uint x, uint c);
+OVERLOADABLE short intel_sub_group_shuffle(short x, uint c);
+OVERLOADABLE ushort intel_sub_group_shuffle(ushort x, uint c);
+
+OVERLOADABLE float intel_sub_group_shuffle_down(float x, float y, uint c);
+OVERLOADABLE int intel_sub_group_shuffle_down(int x, int y, uint c);
+OVERLOADABLE uint intel_sub_group_shuffle_down(uint x, uint y, uint c);
+OVERLOADABLE short intel_sub_group_shuffle_down(short x, short y, uint c);
+OVERLOADABLE ushort intel_sub_group_shuffle_down(ushort x, ushort y, uint c);
+
+OVERLOADABLE float intel_sub_group_shuffle_up(float x, float y, uint c);
+OVERLOADABLE int intel_sub_group_shuffle_up(int x, int y, uint c);
+OVERLOADABLE uint intel_sub_group_shuffle_up(uint x, uint y, uint c);
+OVERLOADABLE short intel_sub_group_shuffle_up(short x, short y, uint c);
+OVERLOADABLE ushort intel_sub_group_shuffle_up(ushort x, ushort y, uint c);
+
+OVERLOADABLE float intel_sub_group_shuffle_xor(float x, uint c);
+OVERLOADABLE int intel_sub_group_shuffle_xor(int x, uint c);
+OVERLOADABLE uint intel_sub_group_shuffle_xor(uint x, uint c);
+OVERLOADABLE short intel_sub_group_shuffle_xor(short x, uint c);
+OVERLOADABLE ushort intel_sub_group_shuffle_xor(ushort x, uint c);
+
+/* blocak read/write */
+OVERLOADABLE uint intel_sub_group_block_read(const global uint* p);
+OVERLOADABLE uint2 intel_sub_group_block_read2(const global uint* p);
+OVERLOADABLE uint4 intel_sub_group_block_read4(const global uint* p);
+OVERLOADABLE uint8 intel_sub_group_block_read8(const global uint* p);
+
+OVERLOADABLE void intel_sub_group_block_write(__global uint* p, uint data);
+OVERLOADABLE void intel_sub_group_block_write2(__global uint* p, uint2 data);
+OVERLOADABLE void intel_sub_group_block_write4(__global uint* p, uint4 data);
+OVERLOADABLE void intel_sub_group_block_write8(__global uint* p, uint8 data);
+
+OVERLOADABLE uint intel_sub_group_block_read(image2d_t image, int2 byte_coord);
+OVERLOADABLE uint2 intel_sub_group_block_read2(image2d_t image, int2 byte_coord);
+OVERLOADABLE uint4 intel_sub_group_block_read4(image2d_t image, int2 byte_coord);
+OVERLOADABLE uint8 intel_sub_group_block_read8(image2d_t image, int2 byte_coord);
+
+OVERLOADABLE void intel_sub_group_block_write(image2d_t image, int2 byte_coord, uint data);
+OVERLOADABLE void intel_sub_group_block_write2(image2d_t image, int2 byte_coord, uint2 data);
+OVERLOADABLE void intel_sub_group_block_write4(image2d_t image, int2 byte_coord, uint4 data);
+OVERLOADABLE void intel_sub_group_block_write8(image2d_t image, int2 byte_coord, uint8 data);
+
+OVERLOADABLE uint intel_sub_group_block_read_ui(const global uint* p);
+OVERLOADABLE uint2 intel_sub_group_block_read_ui2(const global uint* p);
+OVERLOADABLE uint4 intel_sub_group_block_read_ui4(const global uint* p);
+OVERLOADABLE uint8 intel_sub_group_block_read_ui8(const global uint* p);
+
+OVERLOADABLE void intel_sub_group_block_write_ui(__global uint* p, uint data);
+OVERLOADABLE void intel_sub_group_block_write_ui2(__global uint* p, uint2 data);
+OVERLOADABLE void intel_sub_group_block_write_ui4(__global uint* p, uint4 data);
+OVERLOADABLE void intel_sub_group_block_write_ui8(__global uint* p, uint8 data);
+
+OVERLOADABLE uint intel_sub_group_block_read_ui(image2d_t image, int2 byte_coord);
+OVERLOADABLE uint2 intel_sub_group_block_read_ui2(image2d_t image, int2 byte_coord);
+OVERLOADABLE uint4 intel_sub_group_block_read_ui4(image2d_t image, int2 byte_coord);
+OVERLOADABLE uint8 intel_sub_group_block_read_ui8(image2d_t image, int2 byte_coord);
+
+OVERLOADABLE void intel_sub_group_block_write_ui(image2d_t image, int2 byte_coord, uint data);
+OVERLOADABLE void intel_sub_group_block_write_ui2(image2d_t image, int2 byte_coord, uint2 data);
+OVERLOADABLE void intel_sub_group_block_write_ui4(image2d_t image, int2 byte_coord, uint4 data);
+OVERLOADABLE void intel_sub_group_block_write_ui8(image2d_t image, int2 byte_coord, uint8 data);
+
+OVERLOADABLE void intel_sub_group_media_block_write_ui(int2 src_byte_offset, int width, int height, uint texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_ui2(int2 src_byte_offset, int width, int height, uint2 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_ui4(int2 src_byte_offset, int width, int height, uint4 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_ui8(int2 src_byte_offset, int width, int height, uint8 texels, image2d_t image);
+
+OVERLOADABLE ushort intel_sub_group_block_read_us(const global ushort* p);
+OVERLOADABLE ushort2 intel_sub_group_block_read_us2(const global ushort* p);
+OVERLOADABLE ushort4 intel_sub_group_block_read_us4(const global ushort* p);
+OVERLOADABLE ushort8 intel_sub_group_block_read_us8(const global ushort* p);
+
+OVERLOADABLE void intel_sub_group_block_write_us(__global ushort* p, ushort data);
+OVERLOADABLE void intel_sub_group_block_write_us2(__global ushort* p, ushort2 data);
+OVERLOADABLE void intel_sub_group_block_write_us4(__global ushort* p, ushort4 data);
+OVERLOADABLE void intel_sub_group_block_write_us8(__global ushort* p, ushort8 data);
+
+OVERLOADABLE ushort intel_sub_group_block_read_us(image2d_t image, int2 byte_coord);
+OVERLOADABLE ushort2 intel_sub_group_block_read_us2(image2d_t image, int2 byte_coord);
+OVERLOADABLE ushort4 intel_sub_group_block_read_us4(image2d_t image, int2 byte_coord);
+OVERLOADABLE ushort8 intel_sub_group_block_read_us8(image2d_t image, int2 byte_coord);
+
+OVERLOADABLE void intel_sub_group_block_write_us(image2d_t image, int2 byte_coord, ushort data);
+OVERLOADABLE void intel_sub_group_block_write_us2(image2d_t image, int2 byte_coord, ushort2 data);
+OVERLOADABLE void intel_sub_group_block_write_us4(image2d_t image, int2 byte_coord, ushort4 data);
+OVERLOADABLE void intel_sub_group_block_write_us8(image2d_t image, int2 byte_coord, ushort8 data);
+
+OVERLOADABLE void intel_sub_group_media_block_write_uc(int2 src_byte_offset, int width, int height, uchar texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_uc2(int2 src_byte_offset, int width, int height, uchar2 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_uc4(int2 src_byte_offset, int width, int height, uchar4 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_uc8(int2 src_byte_offset, int width, int height, uchar8 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_uc16(int2 src_byte_offset, int width, int height, uchar16 texels, image2d_t image);
+
+OVERLOADABLE void intel_sub_group_media_block_write_us(int2 src_byte_offset, int width, int height, ushort texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_us2(int2 src_byte_offset, int width, int height, ushort2 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_us4(int2 src_byte_offset, int width, int height, ushort4 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_us8(int2 src_byte_offset, int width, int height, ushort8 texels, image2d_t image);
+OVERLOADABLE void intel_sub_group_media_block_write_us16(int2 src_byte_offset, int width, int height, ushort16 texels, image2d_t image);
+
+OVERLOADABLE uchar intel_sub_group_media_block_read_uc(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uchar2 intel_sub_group_media_block_read_uc2(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uchar4 intel_sub_group_media_block_read_uc4(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uchar8 intel_sub_group_media_block_read_uc8(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uchar16 intel_sub_group_media_block_read_uc16(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+
+OVERLOADABLE ushort intel_sub_group_media_block_read_us(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE ushort2 intel_sub_group_media_block_read_us2(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE ushort4 intel_sub_group_media_block_read_us4(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE ushort8 intel_sub_group_media_block_read_us8(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE ushort16 intel_sub_group_media_block_read_us16(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+
+OVERLOADABLE uint intel_sub_group_media_block_read_ui(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uint2 intel_sub_group_media_block_read_ui2(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uint4 intel_sub_group_media_block_read_ui4(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+OVERLOADABLE uint8 intel_sub_group_media_block_read_ui8(int2 src_byte_offset, int width, int height, read_only image2d_t image);
+//Begin from this part is autogenerated.
+//Don't modify it manually.
+//simd level functions builtin functions
+//floatn intel_sub_group_shuffle(floatn x, uint c)
+
+OVERLOADABLE float2 intel_sub_group_shuffle (float2 param0, uint param1);
+OVERLOADABLE float3 intel_sub_group_shuffle (float3 param0, uint param1);
+OVERLOADABLE float4 intel_sub_group_shuffle (float4 param0, uint param1);
+OVERLOADABLE float8 intel_sub_group_shuffle (float8 param0, uint param1);
+OVERLOADABLE float16 intel_sub_group_shuffle (float16 param0, uint param1);
+
+//intn intel_sub_group_shuffle(intn x, uint c)
+
+OVERLOADABLE int2 intel_sub_group_shuffle (int2 param0, uint param1);
+OVERLOADABLE int3 intel_sub_group_shuffle (int3 param0, uint param1);
+OVERLOADABLE int4 intel_sub_group_shuffle (int4 param0, uint param1);
+OVERLOADABLE int8 intel_sub_group_shuffle (int8 param0, uint param1);
+OVERLOADABLE int16 intel_sub_group_shuffle (int16 param0, uint param1);
+
+//uintn intel_sub_group_shuffle(uintn x, uint c)
+
+OVERLOADABLE uint2 intel_sub_group_shuffle (uint2 param0, uint param1);
+OVERLOADABLE uint3 intel_sub_group_shuffle (uint3 param0, uint param1);
+OVERLOADABLE uint4 intel_sub_group_shuffle (uint4 param0, uint param1);
+OVERLOADABLE uint8 intel_sub_group_shuffle (uint8 param0, uint param1);
+OVERLOADABLE uint16 intel_sub_group_shuffle (uint16 param0, uint param1);
+
+//floatn intel_sub_group_shuffle_down(floatn x, floatn y, uint c)
+
+OVERLOADABLE float2 intel_sub_group_shuffle_down (float2 param0, float2 param1, uint param2);
+OVERLOADABLE float3 intel_sub_group_shuffle_down (float3 param0, float3 param1, uint param2);
+OVERLOADABLE float4 intel_sub_group_shuffle_down (float4 param0, float4 param1, uint param2);
+OVERLOADABLE float8 intel_sub_group_shuffle_down (float8 param0, float8 param1, uint param2);
+OVERLOADABLE float16 intel_sub_group_shuffle_down (float16 param0, float16 param1, uint param2);
+
+//intn intel_sub_group_shuffle_down(intn x, intn y, uint c)
+
+OVERLOADABLE int2 intel_sub_group_shuffle_down (int2 param0, int2 param1, uint param2);
+OVERLOADABLE int3 intel_sub_group_shuffle_down (int3 param0, int3 param1, uint param2);
+OVERLOADABLE int4 intel_sub_group_shuffle_down (int4 param0, int4 param1, uint param2);
+OVERLOADABLE int8 intel_sub_group_shuffle_down (int8 param0, int8 param1, uint param2);
+OVERLOADABLE int16 intel_sub_group_shuffle_down (int16 param0, int16 param1, uint param2);
+
+//uintn intel_sub_group_shuffle_down(uintn x, uintn y, uint c)
+
+OVERLOADABLE uint2 intel_sub_group_shuffle_down (uint2 param0, uint2 param1, uint param2);
+OVERLOADABLE uint3 intel_sub_group_shuffle_down (uint3 param0, uint3 param1, uint param2);
+OVERLOADABLE uint4 intel_sub_group_shuffle_down (uint4 param0, uint4 param1, uint param2);
+OVERLOADABLE uint8 intel_sub_group_shuffle_down (uint8 param0, uint8 param1, uint param2);
+OVERLOADABLE uint16 intel_sub_group_shuffle_down (uint16 param0, uint16 param1, uint param2);
+
+//floatn intel_sub_group_shuffle_up(floatn x, floatn y, uint c)
+
+OVERLOADABLE float2 intel_sub_group_shuffle_up (float2 param0, float2 param1, uint param2);
+OVERLOADABLE float3 intel_sub_group_shuffle_up (float3 param0, float3 param1, uint param2);
+OVERLOADABLE float4 intel_sub_group_shuffle_up (float4 param0, float4 param1, uint param2);
+OVERLOADABLE float8 intel_sub_group_shuffle_up (float8 param0, float8 param1, uint param2);
+OVERLOADABLE float16 intel_sub_group_shuffle_up (float16 param0, float16 param1, uint param2);
+
+//intn intel_sub_group_shuffle_up(intn x, intn y, uint c)
+
+OVERLOADABLE int2 intel_sub_group_shuffle_up (int2 param0, int2 param1, uint param2);
+OVERLOADABLE int3 intel_sub_group_shuffle_up (int3 param0, int3 param1, uint param2);
+OVERLOADABLE int4 intel_sub_group_shuffle_up (int4 param0, int4 param1, uint param2);
+OVERLOADABLE int8 intel_sub_group_shuffle_up (int8 param0, int8 param1, uint param2);
+OVERLOADABLE int16 intel_sub_group_shuffle_up (int16 param0, int16 param1, uint param2);
+
+//uintn intel_sub_group_shuffle_up(uintn x, uintn y, uint c)
+
+OVERLOADABLE uint2 intel_sub_group_shuffle_up (uint2 param0, uint2 param1, uint param2);
+OVERLOADABLE uint3 intel_sub_group_shuffle_up (uint3 param0, uint3 param1, uint param2);
+OVERLOADABLE uint4 intel_sub_group_shuffle_up (uint4 param0, uint4 param1, uint param2);
+OVERLOADABLE uint8 intel_sub_group_shuffle_up (uint8 param0, uint8 param1, uint param2);
+OVERLOADABLE uint16 intel_sub_group_shuffle_up (uint16 param0, uint16 param1, uint param2);
+
+//floatn intel_sub_group_shuffle_xor(floatn x, uint c)
+
+OVERLOADABLE float2 intel_sub_group_shuffle_xor (float2 param0, uint param1);
+OVERLOADABLE float3 intel_sub_group_shuffle_xor (float3 param0, uint param1);
+OVERLOADABLE float4 intel_sub_group_shuffle_xor (float4 param0, uint param1);
+OVERLOADABLE float8 intel_sub_group_shuffle_xor (float8 param0, uint param1);
+OVERLOADABLE float16 intel_sub_group_shuffle_xor (float16 param0, uint param1);
+
+//intn intel_sub_group_shuffle_xor(intn x, uint c)
+
+OVERLOADABLE int2 intel_sub_group_shuffle_xor (int2 param0, uint param1);
+OVERLOADABLE int3 intel_sub_group_shuffle_xor (int3 param0, uint param1);
+OVERLOADABLE int4 intel_sub_group_shuffle_xor (int4 param0, uint param1);
+OVERLOADABLE int8 intel_sub_group_shuffle_xor (int8 param0, uint param1);
+OVERLOADABLE int16 intel_sub_group_shuffle_xor (int16 param0, uint param1);
+
+//uintn intel_sub_group_shuffle_xor(uintn x, uint c)
+
+OVERLOADABLE uint2 intel_sub_group_shuffle_xor (uint2 param0, uint param1);
+OVERLOADABLE uint3 intel_sub_group_shuffle_xor (uint3 param0, uint param1);
+OVERLOADABLE uint4 intel_sub_group_shuffle_xor (uint4 param0, uint param1);
+OVERLOADABLE uint8 intel_sub_group_shuffle_xor (uint8 param0, uint param1);
+OVERLOADABLE uint16 intel_sub_group_shuffle_xor (uint16 param0, uint param1);
+
+#endif
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_sync.h b/drivers/pocl-gen7/lib/beignet/include/ocl_sync.h
new file mode 100644
index 0000000..22ff89a
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_sync.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_SYNC_H__
+#define __OCL_SYNC_H__
+
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Synchronization functions
+/////////////////////////////////////////////////////////////////////////////
+OVERLOADABLE void barrier(cl_mem_fence_flags flags);
+OVERLOADABLE void debugwait(void);
+OVERLOADABLE void mem_fence(cl_mem_fence_flags flags);
+OVERLOADABLE void read_mem_fence(cl_mem_fence_flags flags);
+OVERLOADABLE void write_mem_fence(cl_mem_fence_flags flags);
+#define work_group_barrier barrier
+cl_mem_fence_flags get_fence(void *ptr);
+#endif  /* __OCL_SYNC_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_types.h b/drivers/pocl-gen7/lib/beignet/include/ocl_types.h
new file mode 100644
index 0000000..327624b
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_types.h
@@ -0,0 +1,128 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_TYPES_H__
+#define __OCL_TYPES_H__
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+#define DISABLE_ATOMIC_INT64
+#ifndef DISABLE_ATOMIC_INT64
+#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable
+#endif
+#include "ocl_defines.h"
+
+#define NULL 0
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL Common Defines
+/////////////////////////////////////////////////////////////////////////////
+#define INLINE inline __attribute__((always_inline))
+#define OVERLOADABLE __attribute__((overloadable))
+#define PURE __attribute__((pure))
+#define CONST __attribute__((const))
+#define INLINE_OVERLOADABLE inline __attribute__((overloadable,always_inline))
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL built-in scalar data types
+/////////////////////////////////////////////////////////////////////////////
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+typedef __typeof__(sizeof(int)) size_t;
+typedef __typeof__((int *)0-(int *)0) ptrdiff_t;
+#define __int_t_type(a,b,c) a##b##c
+#define __int_type(type,n) __int_t_type(type,n,_TYPE__)
+typedef __int_type(__INT,__INTPTR_WIDTH__) intptr_t;
+typedef __int_type(__UINT,__INTPTR_WIDTH__) uintptr_t;
+#undef __int_type
+#undef __int_t_type
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL address space
+/////////////////////////////////////////////////////////////////////////////
+// These are built-ins in LLVM 3.3.
+#if 100*__clang_major__ + __clang_minor__ <= 302
+#define __private __attribute__((address_space(0)))
+#define __global __attribute__((address_space(1)))
+#define __constant __attribute__((address_space(2)))
+#define __local __attribute__((address_space(3)))
+#define global __global
+#define local __local
+#define constant __constant
+#define private __private
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL built-in vector data types
+/////////////////////////////////////////////////////////////////////////////
+#define DEF(type) typedef type type##2 __attribute__((ext_vector_type(2)));\
+                  typedef type type##3 __attribute__((ext_vector_type(3)));\
+                  typedef type type##4 __attribute__((ext_vector_type(4)));\
+                  typedef type type##8 __attribute__((ext_vector_type(8)));\
+                  typedef type type##16 __attribute__((ext_vector_type(16)));
+DEF(char);
+DEF(uchar);
+DEF(short);
+DEF(ushort);
+DEF(int);
+DEF(uint);
+DEF(long);
+DEF(ulong);
+DEF(float);
+DEF(double);
+DEF(half);
+#undef DEF
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL atomic related types
+/////////////////////////////////////////////////////////////////////////////
+//atomic flags
+#define CLK_LOCAL_MEM_FENCE  (1 << 0)
+#define CLK_GLOBAL_MEM_FENCE (1 << 1)
+#define  CLK_IMAGE_MEM_FENCE (1 << 2)
+
+typedef uint cl_mem_fence_flags;
+
+//memory order
+typedef enum {
+	memory_order_relaxed,
+	memory_order_acquire,
+	memory_order_release,
+	memory_order_acq_rel,
+	memory_order_seq_cst
+} memory_order;
+
+//memory scope
+typedef enum {
+	memory_scope_work_item,
+	memory_scope_work_group,
+	memory_scope_device,
+	memory_scope_all_svm_devices,
+	memory_scope_sub_group,
+} memory_scope;
+
+/////////////////////////////////////////////////////////////////////////////
+// OpenCL built-in event types
+/////////////////////////////////////////////////////////////////////////////
+// FIXME:
+// This is a transitional hack to bypass the LLVM 3.3 built-in types.
+// See the Khronos SPIR specification for handling of these types.
+
+#endif /* __OCL_TYPES_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_vload.h b/drivers/pocl-gen7/lib/beignet/include/ocl_vload.h
new file mode 100644
index 0000000..c26f640
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_vload.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_VLOAD_H__
+#define __OCL_VLOAD_H__
+
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Vector loads and stores
+/////////////////////////////////////////////////////////////////////////////
+
+// These loads and stores will use untyped reads and writes, so we can just
+// cast to vector loads / stores. Not C99 compliant BTW due to aliasing issue.
+// Well we do not care, we do not activate TBAA in the compiler
+#define DECL_UNTYPED_RW_SPACE_N(TYPE, DIM, SPACE) \
+OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p); \
+OVERLOADABLE void vstore##DIM(TYPE##DIM v, size_t offset, SPACE TYPE *p);
+
+#define DECL_UNTYPED_RD_SPACE_N(TYPE, DIM, SPACE) \
+OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p);
+
+#define DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \
+OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p);
+
+#define DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \
+OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p);
+
+#define DECL_UNTYPED_RW_ALL_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 2, SPACE) \
+  DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 4, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 8, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 16, SPACE)
+
+#define DECL_UNTYPED_RD_ALL_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 2, SPACE) \
+  DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 4, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 8, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 16, SPACE)
+
+#define DECL_UNTYPED_RW_ALL(TYPE) \
+  DECL_UNTYPED_RW_ALL_SPACE(TYPE, __global) \
+  DECL_UNTYPED_RW_ALL_SPACE(TYPE, __local) \
+  DECL_UNTYPED_RD_ALL_SPACE(TYPE, __constant) \
+  DECL_UNTYPED_RW_ALL_SPACE(TYPE, __private)
+
+#define DECL_BYTE_RD_SPACE(TYPE, SPACE) \
+OVERLOADABLE TYPE##2 vload2(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##4 vload4(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##8 vload8(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##16 vload16(size_t offset, const SPACE TYPE *p);
+
+#define DECL_BYTE_WR_SPACE(TYPE, SPACE) \
+OVERLOADABLE void vstore2(TYPE##2 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore4(TYPE##4 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore8(TYPE##8 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore16(TYPE##16 v, size_t offset, SPACE TYPE *p);
+
+#define DECL_BYTE_RW_ALL(TYPE) \
+  DECL_BYTE_RD_SPACE(TYPE, __global) \
+  DECL_BYTE_RD_SPACE(TYPE, __local) \
+  DECL_BYTE_RD_SPACE(TYPE, __private) \
+  DECL_BYTE_RD_SPACE(TYPE, __constant) \
+  DECL_BYTE_WR_SPACE(TYPE, __global) \
+  DECL_BYTE_WR_SPACE(TYPE, __local) \
+  DECL_BYTE_WR_SPACE(TYPE, __private)
+
+DECL_BYTE_RW_ALL(char)
+DECL_BYTE_RW_ALL(uchar)
+DECL_BYTE_RW_ALL(short)
+DECL_BYTE_RW_ALL(ushort)
+DECL_BYTE_RW_ALL(half)
+DECL_UNTYPED_RW_ALL(int)
+DECL_UNTYPED_RW_ALL(uint)
+DECL_UNTYPED_RW_ALL(long)
+DECL_UNTYPED_RW_ALL(ulong)
+DECL_UNTYPED_RW_ALL(float)
+DECL_UNTYPED_RW_ALL(double)
+
+#undef DECL_UNTYPED_RW_ALL
+#undef DECL_UNTYPED_RW_ALL_SPACE
+#undef DECL_UNTYPED_RD_ALL_SPACE
+#undef DECL_UNTYPED_RW_SPACE_N
+#undef DECL_UNTYPED_RD_SPACE_N
+#undef DECL_UNTYPED_V3_SPACE
+#undef DECL_UNTYPED_RDV3_SPACE
+#undef DECL_BYTE_RD_SPACE
+#undef DECL_BYTE_WR_SPACE
+#undef DECL_BYTE_RW_ALL
+
+
+#define DECL_HALF_LD_SPACE(SPACE) \
+OVERLOADABLE float vload_half(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float vloada_half(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float2 vload_half2(size_t offset, const SPACE half *p); \
+OVERLOADABLE float2 vloada_half2(size_t offset, const SPACE half *p); \
+OVERLOADABLE float3 vload_half3(size_t offset, const SPACE half *p); \
+OVERLOADABLE float3 vloada_half3(size_t offset, const SPACE half *p); \
+OVERLOADABLE float4 vload_half4(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float4 vloada_half4(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float8 vload_half8(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float8 vloada_half8(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float16 vload_half16(size_t offset, const SPACE half *p); \
+OVERLOADABLE float16 vloada_half16(size_t offset, const SPACE half *p); \
+
+#define DECL_HALF_ST_SPACE_ROUND(SPACE, ROUND, FUNC) \
+OVERLOADABLE void vstore_half##ROUND(float data, size_t offset, SPACE half *p);  \
+OVERLOADABLE void vstorea_half##ROUND(float data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half2##ROUND(float2 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half2##ROUND(float2 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half3##ROUND(float3 data, size_t offset, SPACE half *p);  \
+OVERLOADABLE void vstorea_half3##ROUND(float3 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half4##ROUND(float4 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half4##ROUND(float4 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half8##ROUND(float8 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half8##ROUND(float8 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half16##ROUND(float16 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half16##ROUND(float16 data, size_t offset, SPACE half *p);
+
+#define DECL_HALF_ST_SPACE(SPACE) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE,  , dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rte, dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rtz, dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rtp, dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rtn, dummy) \
+
+DECL_HALF_LD_SPACE(__global)
+DECL_HALF_LD_SPACE(__local)
+DECL_HALF_LD_SPACE(__constant)
+DECL_HALF_LD_SPACE(__private)
+
+DECL_HALF_ST_SPACE(__global)
+DECL_HALF_ST_SPACE(__local)
+DECL_HALF_ST_SPACE(__private)
+
+//#undef DECL_UNTYPED_RW_ALL_SPACE
+#undef DECL_HALF_LD_SPACE
+#undef DECL_HALF_ST_SPACE
+#undef DECL_HALF_ST_SPACE_ROUND
+
+#endif  /* __OCL_VLOAD_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_vload_20.h b/drivers/pocl-gen7/lib/beignet/include/ocl_vload_20.h
new file mode 100644
index 0000000..3f7fc62
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_vload_20.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_VLOAD_20_H__
+#define __OCL_VLOAD_20_H__
+
+#include "ocl_types.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// Vector loads and stores
+/////////////////////////////////////////////////////////////////////////////
+
+// These loads and stores will use untyped reads and writes, so we can just
+// cast to vector loads / stores. Not C99 compliant BTW due to aliasing issue.
+// Well we do not care, we do not activate TBAA in the compiler
+#define DECL_UNTYPED_RW_SPACE_N(TYPE, DIM, SPACE) \
+OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p); \
+OVERLOADABLE void vstore##DIM(TYPE##DIM v, size_t offset, SPACE TYPE *p);
+
+#define DECL_UNTYPED_RD_SPACE_N(TYPE, DIM, SPACE) \
+OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p);
+
+#define DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \
+OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p);
+
+#define DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \
+OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p);
+
+#define DECL_UNTYPED_RW_ALL_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 2, SPACE) \
+  DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 4, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 8, SPACE) \
+  DECL_UNTYPED_RW_SPACE_N(TYPE, 16, SPACE)
+
+#define DECL_UNTYPED_RD_ALL_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 2, SPACE) \
+  DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 4, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 8, SPACE) \
+  DECL_UNTYPED_RD_SPACE_N(TYPE, 16, SPACE)
+
+#define DECL_UNTYPED_RW_ALL(TYPE) \
+  DECL_UNTYPED_RD_ALL_SPACE(TYPE, __constant) \
+  DECL_UNTYPED_RW_ALL_SPACE(TYPE, __generic)
+
+#define DECL_BYTE_RD_SPACE(TYPE, SPACE) \
+OVERLOADABLE TYPE##2 vload2(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##4 vload4(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##8 vload8(size_t offset, const SPACE TYPE *p);  \
+OVERLOADABLE TYPE##16 vload16(size_t offset, const SPACE TYPE *p);
+
+#define DECL_BYTE_WR_SPACE(TYPE, SPACE) \
+OVERLOADABLE void vstore2(TYPE##2 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore4(TYPE##4 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore8(TYPE##8 v, size_t offset, SPACE TYPE *p); \
+OVERLOADABLE void vstore16(TYPE##16 v, size_t offset, SPACE TYPE *p);
+
+#define DECL_BYTE_RW_ALL(TYPE) \
+  DECL_BYTE_RD_SPACE(TYPE, __generic) \
+  DECL_BYTE_WR_SPACE(TYPE, __generic) \
+  DECL_BYTE_RD_SPACE(TYPE, __constant)
+
+DECL_BYTE_RW_ALL(char)
+DECL_BYTE_RW_ALL(uchar)
+DECL_BYTE_RW_ALL(short)
+DECL_BYTE_RW_ALL(ushort)
+DECL_BYTE_RW_ALL(half)
+DECL_UNTYPED_RW_ALL(int)
+DECL_UNTYPED_RW_ALL(uint)
+DECL_UNTYPED_RW_ALL(long)
+DECL_UNTYPED_RW_ALL(ulong)
+DECL_UNTYPED_RW_ALL(float)
+DECL_UNTYPED_RW_ALL(double)
+
+#undef DECL_UNTYPED_RW_ALL
+#undef DECL_UNTYPED_RW_ALL_SPACE
+#undef DECL_UNTYPED_RD_ALL_SPACE
+#undef DECL_UNTYPED_RW_SPACE_N
+#undef DECL_UNTYPED_RD_SPACE_N
+#undef DECL_UNTYPED_V3_SPACE
+#undef DECL_UNTYPED_RDV3_SPACE
+#undef DECL_BYTE_RD_SPACE
+#undef DECL_BYTE_WR_SPACE
+#undef DECL_BYTE_RW_ALL
+
+
+#define DECL_HALF_LD_SPACE(SPACE) \
+OVERLOADABLE float vload_half(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float vloada_half(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float2 vload_half2(size_t offset, const SPACE half *p); \
+OVERLOADABLE float2 vloada_half2(size_t offset, const SPACE half *p); \
+OVERLOADABLE float3 vload_half3(size_t offset, const SPACE half *p); \
+OVERLOADABLE float3 vloada_half3(size_t offset, const SPACE half *p); \
+OVERLOADABLE float4 vload_half4(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float4 vloada_half4(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float8 vload_half8(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float8 vloada_half8(size_t offset, const SPACE half *p);  \
+OVERLOADABLE float16 vload_half16(size_t offset, const SPACE half *p); \
+OVERLOADABLE float16 vloada_half16(size_t offset, const SPACE half *p); \
+
+#define DECL_HALF_ST_SPACE_ROUND(SPACE, ROUND, FUNC) \
+OVERLOADABLE void vstore_half##ROUND(float data, size_t offset, SPACE half *p);  \
+OVERLOADABLE void vstorea_half##ROUND(float data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half2##ROUND(float2 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half2##ROUND(float2 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half3##ROUND(float3 data, size_t offset, SPACE half *p);  \
+OVERLOADABLE void vstorea_half3##ROUND(float3 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half4##ROUND(float4 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half4##ROUND(float4 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half8##ROUND(float8 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half8##ROUND(float8 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstore_half16##ROUND(float16 data, size_t offset, SPACE half *p); \
+OVERLOADABLE void vstorea_half16##ROUND(float16 data, size_t offset, SPACE half *p);
+
+#define DECL_HALF_ST_SPACE(SPACE) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE,  , dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rte, dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rtz, dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rtp, dummy) \
+  DECL_HALF_ST_SPACE_ROUND(SPACE, _rtn, dummy) \
+
+DECL_HALF_LD_SPACE(__constant)
+DECL_HALF_LD_SPACE(__generic)
+
+DECL_HALF_ST_SPACE(__generic)
+
+//#undef DECL_UNTYPED_RW_ALL_SPACE
+#undef DECL_HALF_LD_SPACE
+#undef DECL_HALF_ST_SPACE
+#undef DECL_HALF_ST_SPACE_ROUND
+
+#endif  /* __OCL_VLOAD_20_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_work_group.h b/drivers/pocl-gen7/lib/beignet/include/ocl_work_group.h
new file mode 100644
index 0000000..ebd264f
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_work_group.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_WORK_GROUP_H__
+#define __OCL_WORK_GROUP_H__
+#include "ocl_types.h"
+
+int work_group_all(int predicate);
+int work_group_any(int predicate);
+
+/* broadcast */
+OVERLOADABLE int work_group_broadcast(int a, size_t local_id);
+OVERLOADABLE uint work_group_broadcast(uint a, size_t local_id);
+OVERLOADABLE long work_group_broadcast(long a, size_t local_id);
+OVERLOADABLE ulong work_group_broadcast(ulong a, size_t local_id);
+OVERLOADABLE float work_group_broadcast(float a, size_t local_id);
+OVERLOADABLE double work_group_broadcast(double a, size_t local_id);
+
+OVERLOADABLE int work_group_broadcast(int a, size_t local_id_x, size_t local_id_y);
+OVERLOADABLE uint work_group_broadcast(uint a, size_t local_id_x, size_t local_id_y);
+OVERLOADABLE long work_group_broadcast(long a, size_t local_id_x, size_t local_id_y);
+OVERLOADABLE ulong work_group_broadcast(ulong a, size_t local_id_x, size_t local_id_y);
+OVERLOADABLE float work_group_broadcast(float a, size_t local_id_x, size_t local_id_y);
+OVERLOADABLE double work_group_broadcast(double a, size_t local_id_x, size_t local_id_y);
+
+OVERLOADABLE int work_group_broadcast(int a, size_t local_id_x, size_t local_id_y, size_t local_id_z);
+OVERLOADABLE uint work_group_broadcast(uint a, size_t local_id_x, size_t local_id_y, size_t local_id_z);
+OVERLOADABLE long work_group_broadcast(long a, size_t local_id_x, size_t local_id_y, size_t local_id_z);
+OVERLOADABLE ulong work_group_broadcast(ulong a, size_t local_id_x, size_t local_id_y, size_t local_id_z);
+OVERLOADABLE float work_group_broadcast(float a, size_t local_id_x, size_t local_id_y, size_t local_id_z);
+OVERLOADABLE double work_group_broadcast(double a, size_t local_id_x, size_t local_id_y, size_t local_id_z);
+
+/* reduce add */
+OVERLOADABLE int work_group_reduce_add(int x);
+OVERLOADABLE uint work_group_reduce_add(uint x);
+OVERLOADABLE long work_group_reduce_add(long x);
+OVERLOADABLE ulong work_group_reduce_add(ulong x);
+OVERLOADABLE float work_group_reduce_add(float x);
+OVERLOADABLE double work_group_reduce_add(double x);
+
+/* reduce min */
+OVERLOADABLE int work_group_reduce_min(int x);
+OVERLOADABLE uint work_group_reduce_min(uint x);
+OVERLOADABLE long work_group_reduce_min(long x);
+OVERLOADABLE ulong work_group_reduce_min(ulong x);
+OVERLOADABLE float work_group_reduce_min(float x);
+OVERLOADABLE double work_group_reduce_min(double x);
+
+/* reduce max */
+OVERLOADABLE int work_group_reduce_max(int x);
+OVERLOADABLE uint work_group_reduce_max(uint x);
+OVERLOADABLE long work_group_reduce_max(long x);
+OVERLOADABLE ulong work_group_reduce_max(ulong x);
+OVERLOADABLE float work_group_reduce_max(float x);
+OVERLOADABLE double work_group_reduce_max(double x);
+
+/* scan_inclusive add */
+OVERLOADABLE int work_group_scan_inclusive_add(int x);
+OVERLOADABLE uint work_group_scan_inclusive_add(uint x);
+OVERLOADABLE long work_group_scan_inclusive_add(long x);
+OVERLOADABLE ulong work_group_scan_inclusive_add(ulong x);
+OVERLOADABLE float work_group_scan_inclusive_add(float x);
+OVERLOADABLE double work_group_scan_inclusive_add(double x);
+
+/* scan_inclusive min */
+OVERLOADABLE int work_group_scan_inclusive_min(int x);
+OVERLOADABLE uint work_group_scan_inclusive_min(uint x);
+OVERLOADABLE long work_group_scan_inclusive_min(long x);
+OVERLOADABLE ulong work_group_scan_inclusive_min(ulong x);
+OVERLOADABLE float work_group_scan_inclusive_min(float x);
+OVERLOADABLE double work_group_scan_inclusive_min(double x);
+
+/* scan_inclusive max */
+OVERLOADABLE int work_group_scan_inclusive_max(int x);
+OVERLOADABLE uint work_group_scan_inclusive_max(uint x);
+OVERLOADABLE long work_group_scan_inclusive_max(long x);
+OVERLOADABLE ulong work_group_scan_inclusive_max(ulong x);
+OVERLOADABLE float work_group_scan_inclusive_max(float x);
+OVERLOADABLE double work_group_scan_inclusive_max(double x);
+
+/* scan_exclusive add */
+OVERLOADABLE int work_group_scan_exclusive_add(int x);
+OVERLOADABLE uint work_group_scan_exclusive_add(uint x);
+OVERLOADABLE long work_group_scan_exclusive_add(long x);
+OVERLOADABLE ulong work_group_scan_exclusive_add(ulong x);
+OVERLOADABLE float work_group_scan_exclusive_add(float x);
+OVERLOADABLE double work_group_scan_exclusive_add(double x);
+
+/* scan_exclusive min */
+OVERLOADABLE int work_group_scan_exclusive_min(int x);
+OVERLOADABLE uint work_group_scan_exclusive_min(uint x);
+OVERLOADABLE long work_group_scan_exclusive_min(long x);
+OVERLOADABLE ulong work_group_scan_exclusive_min(ulong x);
+OVERLOADABLE float work_group_scan_exclusive_min(float x);
+OVERLOADABLE double work_group_scan_exclusive_min(double x);
+
+/* scan_exclusive max */
+OVERLOADABLE int work_group_scan_exclusive_max(int x);
+OVERLOADABLE uint work_group_scan_exclusive_max(uint x);
+OVERLOADABLE long work_group_scan_exclusive_max(long x);
+OVERLOADABLE ulong work_group_scan_exclusive_max(ulong x);
+OVERLOADABLE float work_group_scan_exclusive_max(float x);
+OVERLOADABLE double work_group_scan_exclusive_max(double x);
+#endif  /* __OCL_WORK_GROUP_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_workitem.h b/drivers/pocl-gen7/lib/beignet/include/ocl_workitem.h
new file mode 100644
index 0000000..1a96aa8
--- /dev/null
+++ b/drivers/pocl-gen7/lib/beignet/include/ocl_workitem.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2012 - 2014 Intel Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __OCL_WORKITEM_H__
+#define __OCL_WORKITEM_H__
+
+#include "ocl_types.h"
+
+OVERLOADABLE uint get_work_dim(void);
+OVERLOADABLE size_t get_global_size(uint dimindx);
+OVERLOADABLE size_t get_global_id(uint dimindx);
+OVERLOADABLE size_t get_local_size(uint dimindx);
+OVERLOADABLE size_t get_enqueued_local_size(uint dimindx);
+OVERLOADABLE size_t get_local_id(uint dimindx);
+OVERLOADABLE size_t get_num_groups(uint dimindx);
+OVERLOADABLE size_t get_group_id(uint dimindx);
+OVERLOADABLE size_t get_global_offset(uint dimindx);
+OVERLOADABLE size_t get_global_linear_id(void);
+OVERLOADABLE size_t get_local_linear_id(void);
+
+#endif  /* __OCL_WORKITEM_H__ */
diff --git a/drivers/pocl-gen7/lib/beignet/libgbe.so b/drivers/pocl-gen7/lib/beignet/libgbe.so
new file mode 100755
index 0000000..b7293d3
Binary files /dev/null and b/drivers/pocl-gen7/lib/beignet/libgbe.so differ
diff --git a/drivers/pocl-gen7/lib/beignet/libgbeinterp.so b/drivers/pocl-gen7/lib/beignet/libgbeinterp.so
new file mode 100755
index 0000000..a5f7c5f
Binary files /dev/null and b/drivers/pocl-gen7/lib/beignet/libgbeinterp.so differ
diff --git a/drivers/pocl-gen7/lib/libpocl.so b/drivers/pocl-gen7/lib/libpocl.so
new file mode 120000
index 0000000..e9e9819
--- /dev/null
+++ b/drivers/pocl-gen7/lib/libpocl.so
@@ -0,0 +1 @@
+libpocl.so.2
\ No newline at end of file
diff --git a/drivers/pocl-gen7/lib/libpocl.so.2 b/drivers/pocl-gen7/lib/libpocl.so.2
new file mode 120000
index 0000000..f45462d
--- /dev/null
+++ b/drivers/pocl-gen7/lib/libpocl.so.2
@@ -0,0 +1 @@
+libpocl.so.2.16.0
\ No newline at end of file
diff --git a/drivers/pocl-gen7/lib/libpocl.so.2.16.0 b/drivers/pocl-gen7/lib/libpocl.so.2.16.0
new file mode 100755
index 0000000..5ec0a7e
Binary files /dev/null and b/drivers/pocl-gen7/lib/libpocl.so.2.16.0 differ
diff --git a/drivers/pocl-gen7/lib/pocl/libpocl-devices-basic.so b/drivers/pocl-gen7/lib/pocl/libpocl-devices-basic.so
new file mode 100755
index 0000000..e0a7853
Binary files /dev/null and b/drivers/pocl-gen7/lib/pocl/libpocl-devices-basic.so differ
diff --git a/drivers/pocl-gen7/lib/pocl/libpocl-devices-gen7.so b/drivers/pocl-gen7/lib/pocl/libpocl-devices-gen7.so
new file mode 100755
index 0000000..fac7aa0
Binary files /dev/null and b/drivers/pocl-gen7/lib/pocl/libpocl-devices-gen7.so differ
diff --git a/drivers/pocl-gen7/lib/pocl/libpocl-devices-pthread.so b/drivers/pocl-gen7/lib/pocl/libpocl-devices-pthread.so
new file mode 100755
index 0000000..b0ec813
Binary files /dev/null and b/drivers/pocl-gen7/lib/pocl/libpocl-devices-pthread.so differ
diff --git a/drivers/pocl-gen7/share/pocl/include/_builtin_renames.h b/drivers/pocl-gen7/share/pocl/include/_builtin_renames.h
new file mode 100644
index 0000000..b2b2287
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/_builtin_renames.h
@@ -0,0 +1,1168 @@
+/* pocl/_kernel_renames.h - Rename OpenCL builtin functions to avoid name
+   clashes with libm functions which are called in implementation.
+
+   Copyright (c) 2011-2013 Erik Schnetter <eschnetter@perimeterinstitute.ca>
+                           Perimeter Institute for Theoretical Physics
+   Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+*/
+
+#ifndef _KERNEL_RENAMES_H
+#define _KERNEL_RENAMES_H
+
+/* Move built-in declarations and libm functions out of the way.
+  (There should be a better way of doing so. These functions are
+  built-in math functions for OpenCL (see Clang's "Builtins.def").
+
+  Functions defined in libc or libm may also
+  interfere with OpenCL's functions, since their prototypes will be
+  wrong.
+
+  We're not using libm anymore, but renames are still important
+  for SPIR/SPIR-V support. SPIR mangling is different, but when
+  ocassionally it's the same, it still has different calling
+  convention; LLVM can replace illegal calls (with incorrect CC)
+  with an illegal instruction.
+*/
+
+#define abs            _cl_abs
+#define abs_diff       _cl_abs_diff
+#define acos           _cl_acos
+#define acosh          _cl_acosh
+#define acospi         _cl_acospi
+#define add_sat        _cl_add_sat
+#define all            _cl_all
+#define any            _cl_any
+#define asin           _cl_asin
+#define asinh          _cl_asinh
+#define asinpi         _cl_asinpi
+#define async_work_group_strided_copy   _cl_async_work_group_strided_copy
+#define async_work_group_copy   _cl_async_work_group_copy
+#define atan           _cl_atan
+#define atan2          _cl_atan2
+#define atan2pi        _cl_atan2pi
+#define atanh          _cl_atanh
+#define atanpi         _cl_atanpi
+#define bitselect      _cl_bitselect
+#define cbrt           _cl_cbrt
+#define ceil           _cl_ceil
+#define clamp          _cl_clamp
+#define clz            _cl_clz
+#define copysign       _cl_copysign
+#define cos            _cl_cos
+#define cosh           _cl_cosh
+#define cospi          _cl_cospi
+#define cross          _cl_cross
+#define ctz            _cl_ctz
+#define degrees        _cl_degrees
+#define distance       _cl_distance
+#define dot            _cl_dot
+#define erf            _cl_erf
+#define erfc           _cl_erfc
+#define exp            _cl_exp
+#define exp10          _cl_exp10
+#define exp2           _cl_exp2
+#define expm1          _cl_expm1
+#define fabs           _cl_fabs
+#define fast_distance  _cl_fast_distance
+#define fast_length    _cl_fast_length
+#define fast_normalize _cl_fast_normalize
+#define fdim           _cl_fdim
+#define floor          _cl_floor
+#define fma            _cl_fma
+#define fmax           _cl_fmax
+#define fmax_common    _cl_fmax_common
+#define fmin           _cl_fmin
+#define fmin_common    _cl_fmin_common
+#define fmod           _cl_fmod
+#define fract          _cl_fract
+#define frexp          _cl_frexp
+#define hadd           _cl_hadd
+#define half_cos       _cl_half_cos
+#define half_divide    _cl_half_divide
+#define half_exp       _cl_half_exp
+#define half_exp10     _cl_half_exp10
+#define half_exp2      _cl_half_exp2
+#define half_log       _cl_half_log
+#define half_log10     _cl_half_log10
+#define half_log2      _cl_half_log2
+#define half_powr      _cl_half_powr
+#define half_recip     _cl_half_recip
+#define half_rsqrt     _cl_half_rsqrt
+#define half_sin       _cl_half_sin
+#define half_sqrt      _cl_half_sqrt
+#define half_tan       _cl_half_tan
+#define hypot          _cl_hypot
+#define ilogb          _cl_ilogb
+#define isequal        _cl_isequal
+#define isfinite       _cl_isfinite
+#define isgreater      _cl_isgreater
+#define isgreaterequal _cl_isgreaterequal
+#define isinf          _cl_isinf
+#define isless         _cl_isless
+#define islessequal    _cl_islessequal
+#define islessgreater  _cl_islessgreater
+#define isnan          _cl_isnan
+#define isnormal       _cl_isnormal
+#define isnotequal     _cl_isnotequal
+#define isordered      _cl_isordered
+#define isunordered    _cl_isunordered
+#define ldexp          _cl_ldexp
+#define length         _cl_length
+#define lgamma         _cl_lgamma
+#define lgamma_r       _cl_lgamma_r
+#define log            _cl_log
+#define log10          _cl_log10
+#define log1p          _cl_log1p
+#define log2           _cl_log2
+#define logb           _cl_logb
+#define mad            _cl_mad
+#define mad24          _cl_mad24
+#define mad_hi         _cl_mad_hi
+#define mad_sat        _cl_mad_sat
+#define max            _cl_max
+#define maxmag         _cl_maxmag
+#define min            _cl_min
+#define minmag         _cl_minmag
+#define mix            _cl_mix
+#define modf           _cl_modf
+#define mul24          _cl_mul24
+#define mul_hi         _cl_mul_hi
+#define nan            _cl_nan
+#define native_cos     _cl_native_cos
+#define native_divide  _cl_native_divide
+#define native_exp     _cl_native_exp
+#define native_exp10   _cl_native_exp10
+#define native_exp2    _cl_native_exp2
+#define native_log     _cl_native_log
+#define native_log10   _cl_native_log10
+#define native_log2    _cl_native_log2
+#define native_powr    _cl_native_powr
+#define native_recip   _cl_native_recip
+#define native_rsqrt   _cl_native_rsqrt
+#define native_sin     _cl_native_sin
+#define native_sqrt    _cl_native_sqrt
+#define native_tan     _cl_native_tan
+#define nextafter      _cl_nextafter
+#define normalize      _cl_normalize
+#define popcount       _cl_popcount
+#define pow            _cl_pow
+#define pown           _cl_pown
+#define powr           _cl_powr
+#define prefetch       _cl_prefetch
+#define radians        _cl_radians
+#define remainder      _cl_remainder
+#define remquo         _cl_remquo
+#define rhadd          _cl_rhadd
+#define rint           _cl_rint
+#define rootn          _cl_rootn
+#define rotate         _cl_rotate
+#define round          _cl_round
+#define rsqrt          _cl_rsqrt
+#define select         _cl_select
+#define shuffle        _cl_shuffle
+#define shuffle2        _cl_shuffle2
+#define sign           _cl_sign
+#define signbit        _cl_signbit
+#define sin            _cl_sin
+#define sincos         _cl_sincos
+#define sinh           _cl_sinh
+#define sinpi          _cl_sinpi
+#define smoothstep     _cl_smoothstep
+#define sqrt           _cl_sqrt
+#define step           _cl_step
+#define sub_sat        _cl_sub_sat
+#define tan            _cl_tan
+#define tanh           _cl_tanh
+#define tanpi          _cl_tanpi
+#define tgamma         _cl_tgamma
+#define trunc          _cl_trunc
+#define upsample       _cl_upsample
+
+#define  vload   _cl_vload
+#define  vstore  _cl_vstore
+#define  vload_half   _cl_vload_half
+#define  vstore_half  _cl_vstore_half
+#define  vloada_half   _cl_vloada_half
+#define  vstorea_half  _cl_vstorea_half
+#define  vload_half_rte   _cl_vload_half_rte
+#define  vstore_half_rte  _cl_vstore_half_rte
+#define  vloada_half_rte   _cl_vloada_half_rte
+#define  vstorea_half_rte  _cl_vstorea_half_rte
+#define  vload_half_rtz   _cl_vload_half_rtz
+#define  vstore_half_rtz  _cl_vstore_half_rtz
+#define  vloada_half_rtz   _cl_vloada_half_rtz
+#define  vstorea_half_rtz  _cl_vstorea_half_rtz
+#define  vload_half_rtp   _cl_vload_half_rtp
+#define  vstore_half_rtp  _cl_vstore_half_rtp
+#define  vloada_half_rtp   _cl_vloada_half_rtp
+#define  vstorea_half_rtp  _cl_vstorea_half_rtp
+#define  vload_half_rtn   _cl_vload_half_rtn
+#define  vstore_half_rtn  _cl_vstore_half_rtn
+#define  vloada_half_rtn   _cl_vloada_half_rtn
+#define  vstorea_half_rtn  _cl_vstorea_half_rtn
+#define convert_char    _cl_convert_char
+#define convert_uchar    _cl_convert_uchar
+#define convert_short    _cl_convert_short
+#define convert_ushort    _cl_convert_ushort
+#define convert_int    _cl_convert_int
+#define convert_uint    _cl_convert_uint
+#define convert_long    _cl_convert_long
+#define convert_ulong    _cl_convert_ulong
+#define convert_float    _cl_convert_float
+#define convert_double    _cl_convert_double
+#define convert_char_rte    _cl_convert_char_rte
+#define convert_uchar_rte    _cl_convert_uchar_rte
+#define convert_short_rte    _cl_convert_short_rte
+#define convert_ushort_rte    _cl_convert_ushort_rte
+#define convert_int_rte    _cl_convert_int_rte
+#define convert_uint_rte    _cl_convert_uint_rte
+#define convert_long_rte    _cl_convert_long_rte
+#define convert_ulong_rte    _cl_convert_ulong_rte
+#define convert_float_rte    _cl_convert_float_rte
+#define convert_double_rte    _cl_convert_double_rte
+#define convert_char_rtz    _cl_convert_char_rtz
+#define convert_uchar_rtz    _cl_convert_uchar_rtz
+#define convert_short_rtz    _cl_convert_short_rtz
+#define convert_ushort_rtz    _cl_convert_ushort_rtz
+#define convert_int_rtz    _cl_convert_int_rtz
+#define convert_uint_rtz    _cl_convert_uint_rtz
+#define convert_long_rtz    _cl_convert_long_rtz
+#define convert_ulong_rtz    _cl_convert_ulong_rtz
+#define convert_float_rtz    _cl_convert_float_rtz
+#define convert_double_rtz    _cl_convert_double_rtz
+#define convert_char_rtp    _cl_convert_char_rtp
+#define convert_uchar_rtp    _cl_convert_uchar_rtp
+#define convert_short_rtp    _cl_convert_short_rtp
+#define convert_ushort_rtp    _cl_convert_ushort_rtp
+#define convert_int_rtp    _cl_convert_int_rtp
+#define convert_uint_rtp    _cl_convert_uint_rtp
+#define convert_long_rtp    _cl_convert_long_rtp
+#define convert_ulong_rtp    _cl_convert_ulong_rtp
+#define convert_float_rtp    _cl_convert_float_rtp
+#define convert_double_rtp    _cl_convert_double_rtp
+#define convert_char_rtn    _cl_convert_char_rtn
+#define convert_uchar_rtn    _cl_convert_uchar_rtn
+#define convert_short_rtn    _cl_convert_short_rtn
+#define convert_ushort_rtn    _cl_convert_ushort_rtn
+#define convert_int_rtn    _cl_convert_int_rtn
+#define convert_uint_rtn    _cl_convert_uint_rtn
+#define convert_long_rtn    _cl_convert_long_rtn
+#define convert_ulong_rtn    _cl_convert_ulong_rtn
+#define convert_float_rtn    _cl_convert_float_rtn
+#define convert_double_rtn    _cl_convert_double_rtn
+#define convert_char_sat    _cl_convert_char_sat
+#define convert_uchar_sat    _cl_convert_uchar_sat
+#define convert_short_sat    _cl_convert_short_sat
+#define convert_ushort_sat    _cl_convert_ushort_sat
+#define convert_int_sat    _cl_convert_int_sat
+#define convert_uint_sat    _cl_convert_uint_sat
+#define convert_long_sat    _cl_convert_long_sat
+#define convert_ulong_sat    _cl_convert_ulong_sat
+#define convert_float_sat    _cl_convert_float_sat
+#define convert_double_sat    _cl_convert_double_sat
+#define convert_char_sat_rte    _cl_convert_char_sat_rte
+#define convert_uchar_sat_rte    _cl_convert_uchar_sat_rte
+#define convert_short_sat_rte    _cl_convert_short_sat_rte
+#define convert_ushort_sat_rte    _cl_convert_ushort_sat_rte
+#define convert_int_sat_rte    _cl_convert_int_sat_rte
+#define convert_uint_sat_rte    _cl_convert_uint_sat_rte
+#define convert_long_sat_rte    _cl_convert_long_sat_rte
+#define convert_ulong_sat_rte    _cl_convert_ulong_sat_rte
+#define convert_float_sat_rte    _cl_convert_float_sat_rte
+#define convert_double_sat_rte    _cl_convert_double_sat_rte
+#define convert_char_sat_rtz    _cl_convert_char_sat_rtz
+#define convert_uchar_sat_rtz    _cl_convert_uchar_sat_rtz
+#define convert_short_sat_rtz    _cl_convert_short_sat_rtz
+#define convert_ushort_sat_rtz    _cl_convert_ushort_sat_rtz
+#define convert_int_sat_rtz    _cl_convert_int_sat_rtz
+#define convert_uint_sat_rtz    _cl_convert_uint_sat_rtz
+#define convert_long_sat_rtz    _cl_convert_long_sat_rtz
+#define convert_ulong_sat_rtz    _cl_convert_ulong_sat_rtz
+#define convert_float_sat_rtz    _cl_convert_float_sat_rtz
+#define convert_double_sat_rtz    _cl_convert_double_sat_rtz
+#define convert_char_sat_rtp    _cl_convert_char_sat_rtp
+#define convert_uchar_sat_rtp    _cl_convert_uchar_sat_rtp
+#define convert_short_sat_rtp    _cl_convert_short_sat_rtp
+#define convert_ushort_sat_rtp    _cl_convert_ushort_sat_rtp
+#define convert_int_sat_rtp    _cl_convert_int_sat_rtp
+#define convert_uint_sat_rtp    _cl_convert_uint_sat_rtp
+#define convert_long_sat_rtp    _cl_convert_long_sat_rtp
+#define convert_ulong_sat_rtp    _cl_convert_ulong_sat_rtp
+#define convert_float_sat_rtp    _cl_convert_float_sat_rtp
+#define convert_double_sat_rtp    _cl_convert_double_sat_rtp
+#define convert_char_sat_rtn    _cl_convert_char_sat_rtn
+#define convert_uchar_sat_rtn    _cl_convert_uchar_sat_rtn
+#define convert_short_sat_rtn    _cl_convert_short_sat_rtn
+#define convert_ushort_sat_rtn    _cl_convert_ushort_sat_rtn
+#define convert_int_sat_rtn    _cl_convert_int_sat_rtn
+#define convert_uint_sat_rtn    _cl_convert_uint_sat_rtn
+#define convert_long_sat_rtn    _cl_convert_long_sat_rtn
+#define convert_ulong_sat_rtn    _cl_convert_ulong_sat_rtn
+#define convert_float_sat_rtn    _cl_convert_float_sat_rtn
+#define convert_double_sat_rtn    _cl_convert_double_sat_rtn
+
+#define  vload2   _cl_vload2
+#define  vstore2  _cl_vstore2
+#define  vload_half2   _cl_vload_half2
+#define  vstore_half2  _cl_vstore_half2
+#define  vloada_half2   _cl_vloada_half2
+#define  vstorea_half2  _cl_vstorea_half2
+#define  vload_half2_rte   _cl_vload_half2_rte
+#define  vstore_half2_rte  _cl_vstore_half2_rte
+#define  vloada_half2_rte   _cl_vloada_half2_rte
+#define  vstorea_half2_rte  _cl_vstorea_half2_rte
+#define  vload_half2_rtz   _cl_vload_half2_rtz
+#define  vstore_half2_rtz  _cl_vstore_half2_rtz
+#define  vloada_half2_rtz   _cl_vloada_half2_rtz
+#define  vstorea_half2_rtz  _cl_vstorea_half2_rtz
+#define  vload_half2_rtp   _cl_vload_half2_rtp
+#define  vstore_half2_rtp  _cl_vstore_half2_rtp
+#define  vloada_half2_rtp   _cl_vloada_half2_rtp
+#define  vstorea_half2_rtp  _cl_vstorea_half2_rtp
+#define  vload_half2_rtn   _cl_vload_half2_rtn
+#define  vstore_half2_rtn  _cl_vstore_half2_rtn
+#define  vloada_half2_rtn   _cl_vloada_half2_rtn
+#define  vstorea_half2_rtn  _cl_vstorea_half2_rtn
+#define convert_char2    _cl_convert_char2
+#define convert_uchar2    _cl_convert_uchar2
+#define convert_short2    _cl_convert_short2
+#define convert_ushort2    _cl_convert_ushort2
+#define convert_int2    _cl_convert_int2
+#define convert_uint2    _cl_convert_uint2
+#define convert_long2    _cl_convert_long2
+#define convert_ulong2    _cl_convert_ulong2
+#define convert_float2    _cl_convert_float2
+#define convert_double2    _cl_convert_double2
+#define convert_char2_rte    _cl_convert_char2_rte
+#define convert_uchar2_rte    _cl_convert_uchar2_rte
+#define convert_short2_rte    _cl_convert_short2_rte
+#define convert_ushort2_rte    _cl_convert_ushort2_rte
+#define convert_int2_rte    _cl_convert_int2_rte
+#define convert_uint2_rte    _cl_convert_uint2_rte
+#define convert_long2_rte    _cl_convert_long2_rte
+#define convert_ulong2_rte    _cl_convert_ulong2_rte
+#define convert_float2_rte    _cl_convert_float2_rte
+#define convert_double2_rte    _cl_convert_double2_rte
+#define convert_char2_rtz    _cl_convert_char2_rtz
+#define convert_uchar2_rtz    _cl_convert_uchar2_rtz
+#define convert_short2_rtz    _cl_convert_short2_rtz
+#define convert_ushort2_rtz    _cl_convert_ushort2_rtz
+#define convert_int2_rtz    _cl_convert_int2_rtz
+#define convert_uint2_rtz    _cl_convert_uint2_rtz
+#define convert_long2_rtz    _cl_convert_long2_rtz
+#define convert_ulong2_rtz    _cl_convert_ulong2_rtz
+#define convert_float2_rtz    _cl_convert_float2_rtz
+#define convert_double2_rtz    _cl_convert_double2_rtz
+#define convert_char2_rtp    _cl_convert_char2_rtp
+#define convert_uchar2_rtp    _cl_convert_uchar2_rtp
+#define convert_short2_rtp    _cl_convert_short2_rtp
+#define convert_ushort2_rtp    _cl_convert_ushort2_rtp
+#define convert_int2_rtp    _cl_convert_int2_rtp
+#define convert_uint2_rtp    _cl_convert_uint2_rtp
+#define convert_long2_rtp    _cl_convert_long2_rtp
+#define convert_ulong2_rtp    _cl_convert_ulong2_rtp
+#define convert_float2_rtp    _cl_convert_float2_rtp
+#define convert_double2_rtp    _cl_convert_double2_rtp
+#define convert_char2_rtn    _cl_convert_char2_rtn
+#define convert_uchar2_rtn    _cl_convert_uchar2_rtn
+#define convert_short2_rtn    _cl_convert_short2_rtn
+#define convert_ushort2_rtn    _cl_convert_ushort2_rtn
+#define convert_int2_rtn    _cl_convert_int2_rtn
+#define convert_uint2_rtn    _cl_convert_uint2_rtn
+#define convert_long2_rtn    _cl_convert_long2_rtn
+#define convert_ulong2_rtn    _cl_convert_ulong2_rtn
+#define convert_float2_rtn    _cl_convert_float2_rtn
+#define convert_double2_rtn    _cl_convert_double2_rtn
+#define convert_char2_sat    _cl_convert_char2_sat
+#define convert_uchar2_sat    _cl_convert_uchar2_sat
+#define convert_short2_sat    _cl_convert_short2_sat
+#define convert_ushort2_sat    _cl_convert_ushort2_sat
+#define convert_int2_sat    _cl_convert_int2_sat
+#define convert_uint2_sat    _cl_convert_uint2_sat
+#define convert_long2_sat    _cl_convert_long2_sat
+#define convert_ulong2_sat    _cl_convert_ulong2_sat
+#define convert_float2_sat    _cl_convert_float2_sat
+#define convert_double2_sat    _cl_convert_double2_sat
+#define convert_char2_sat_rte    _cl_convert_char2_sat_rte
+#define convert_uchar2_sat_rte    _cl_convert_uchar2_sat_rte
+#define convert_short2_sat_rte    _cl_convert_short2_sat_rte
+#define convert_ushort2_sat_rte    _cl_convert_ushort2_sat_rte
+#define convert_int2_sat_rte    _cl_convert_int2_sat_rte
+#define convert_uint2_sat_rte    _cl_convert_uint2_sat_rte
+#define convert_long2_sat_rte    _cl_convert_long2_sat_rte
+#define convert_ulong2_sat_rte    _cl_convert_ulong2_sat_rte
+#define convert_float2_sat_rte    _cl_convert_float2_sat_rte
+#define convert_double2_sat_rte    _cl_convert_double2_sat_rte
+#define convert_char2_sat_rtz    _cl_convert_char2_sat_rtz
+#define convert_uchar2_sat_rtz    _cl_convert_uchar2_sat_rtz
+#define convert_short2_sat_rtz    _cl_convert_short2_sat_rtz
+#define convert_ushort2_sat_rtz    _cl_convert_ushort2_sat_rtz
+#define convert_int2_sat_rtz    _cl_convert_int2_sat_rtz
+#define convert_uint2_sat_rtz    _cl_convert_uint2_sat_rtz
+#define convert_long2_sat_rtz    _cl_convert_long2_sat_rtz
+#define convert_ulong2_sat_rtz    _cl_convert_ulong2_sat_rtz
+#define convert_float2_sat_rtz    _cl_convert_float2_sat_rtz
+#define convert_double2_sat_rtz    _cl_convert_double2_sat_rtz
+#define convert_char2_sat_rtp    _cl_convert_char2_sat_rtp
+#define convert_uchar2_sat_rtp    _cl_convert_uchar2_sat_rtp
+#define convert_short2_sat_rtp    _cl_convert_short2_sat_rtp
+#define convert_ushort2_sat_rtp    _cl_convert_ushort2_sat_rtp
+#define convert_int2_sat_rtp    _cl_convert_int2_sat_rtp
+#define convert_uint2_sat_rtp    _cl_convert_uint2_sat_rtp
+#define convert_long2_sat_rtp    _cl_convert_long2_sat_rtp
+#define convert_ulong2_sat_rtp    _cl_convert_ulong2_sat_rtp
+#define convert_float2_sat_rtp    _cl_convert_float2_sat_rtp
+#define convert_double2_sat_rtp    _cl_convert_double2_sat_rtp
+#define convert_char2_sat_rtn    _cl_convert_char2_sat_rtn
+#define convert_uchar2_sat_rtn    _cl_convert_uchar2_sat_rtn
+#define convert_short2_sat_rtn    _cl_convert_short2_sat_rtn
+#define convert_ushort2_sat_rtn    _cl_convert_ushort2_sat_rtn
+#define convert_int2_sat_rtn    _cl_convert_int2_sat_rtn
+#define convert_uint2_sat_rtn    _cl_convert_uint2_sat_rtn
+#define convert_long2_sat_rtn    _cl_convert_long2_sat_rtn
+#define convert_ulong2_sat_rtn    _cl_convert_ulong2_sat_rtn
+#define convert_float2_sat_rtn    _cl_convert_float2_sat_rtn
+#define convert_double2_sat_rtn    _cl_convert_double2_sat_rtn
+
+#define  vload3   _cl_vload3
+#define  vstore3  _cl_vstore3
+#define  vload_half3   _cl_vload_half3
+#define  vstore_half3  _cl_vstore_half3
+#define  vloada_half3   _cl_vloada_half3
+#define  vstorea_half3  _cl_vstorea_half3
+#define  vload_half3_rte   _cl_vload_half3_rte
+#define  vstore_half3_rte  _cl_vstore_half3_rte
+#define  vloada_half3_rte   _cl_vloada_half3_rte
+#define  vstorea_half3_rte  _cl_vstorea_half3_rte
+#define  vload_half3_rtz   _cl_vload_half3_rtz
+#define  vstore_half3_rtz  _cl_vstore_half3_rtz
+#define  vloada_half3_rtz   _cl_vloada_half3_rtz
+#define  vstorea_half3_rtz  _cl_vstorea_half3_rtz
+#define  vload_half3_rtp   _cl_vload_half3_rtp
+#define  vstore_half3_rtp  _cl_vstore_half3_rtp
+#define  vloada_half3_rtp   _cl_vloada_half3_rtp
+#define  vstorea_half3_rtp  _cl_vstorea_half3_rtp
+#define  vload_half3_rtn   _cl_vload_half3_rtn
+#define  vstore_half3_rtn  _cl_vstore_half3_rtn
+#define  vloada_half3_rtn   _cl_vloada_half3_rtn
+#define  vstorea_half3_rtn  _cl_vstorea_half3_rtn
+#define convert_char3    _cl_convert_char3
+#define convert_uchar3    _cl_convert_uchar3
+#define convert_short3    _cl_convert_short3
+#define convert_ushort3    _cl_convert_ushort3
+#define convert_int3    _cl_convert_int3
+#define convert_uint3    _cl_convert_uint3
+#define convert_long3    _cl_convert_long3
+#define convert_ulong3    _cl_convert_ulong3
+#define convert_float3    _cl_convert_float3
+#define convert_double3    _cl_convert_double3
+#define convert_char3_rte    _cl_convert_char3_rte
+#define convert_uchar3_rte    _cl_convert_uchar3_rte
+#define convert_short3_rte    _cl_convert_short3_rte
+#define convert_ushort3_rte    _cl_convert_ushort3_rte
+#define convert_int3_rte    _cl_convert_int3_rte
+#define convert_uint3_rte    _cl_convert_uint3_rte
+#define convert_long3_rte    _cl_convert_long3_rte
+#define convert_ulong3_rte    _cl_convert_ulong3_rte
+#define convert_float3_rte    _cl_convert_float3_rte
+#define convert_double3_rte    _cl_convert_double3_rte
+#define convert_char3_rtz    _cl_convert_char3_rtz
+#define convert_uchar3_rtz    _cl_convert_uchar3_rtz
+#define convert_short3_rtz    _cl_convert_short3_rtz
+#define convert_ushort3_rtz    _cl_convert_ushort3_rtz
+#define convert_int3_rtz    _cl_convert_int3_rtz
+#define convert_uint3_rtz    _cl_convert_uint3_rtz
+#define convert_long3_rtz    _cl_convert_long3_rtz
+#define convert_ulong3_rtz    _cl_convert_ulong3_rtz
+#define convert_float3_rtz    _cl_convert_float3_rtz
+#define convert_double3_rtz    _cl_convert_double3_rtz
+#define convert_char3_rtp    _cl_convert_char3_rtp
+#define convert_uchar3_rtp    _cl_convert_uchar3_rtp
+#define convert_short3_rtp    _cl_convert_short3_rtp
+#define convert_ushort3_rtp    _cl_convert_ushort3_rtp
+#define convert_int3_rtp    _cl_convert_int3_rtp
+#define convert_uint3_rtp    _cl_convert_uint3_rtp
+#define convert_long3_rtp    _cl_convert_long3_rtp
+#define convert_ulong3_rtp    _cl_convert_ulong3_rtp
+#define convert_float3_rtp    _cl_convert_float3_rtp
+#define convert_double3_rtp    _cl_convert_double3_rtp
+#define convert_char3_rtn    _cl_convert_char3_rtn
+#define convert_uchar3_rtn    _cl_convert_uchar3_rtn
+#define convert_short3_rtn    _cl_convert_short3_rtn
+#define convert_ushort3_rtn    _cl_convert_ushort3_rtn
+#define convert_int3_rtn    _cl_convert_int3_rtn
+#define convert_uint3_rtn    _cl_convert_uint3_rtn
+#define convert_long3_rtn    _cl_convert_long3_rtn
+#define convert_ulong3_rtn    _cl_convert_ulong3_rtn
+#define convert_float3_rtn    _cl_convert_float3_rtn
+#define convert_double3_rtn    _cl_convert_double3_rtn
+#define convert_char3_sat    _cl_convert_char3_sat
+#define convert_uchar3_sat    _cl_convert_uchar3_sat
+#define convert_short3_sat    _cl_convert_short3_sat
+#define convert_ushort3_sat    _cl_convert_ushort3_sat
+#define convert_int3_sat    _cl_convert_int3_sat
+#define convert_uint3_sat    _cl_convert_uint3_sat
+#define convert_long3_sat    _cl_convert_long3_sat
+#define convert_ulong3_sat    _cl_convert_ulong3_sat
+#define convert_float3_sat    _cl_convert_float3_sat
+#define convert_double3_sat    _cl_convert_double3_sat
+#define convert_char3_sat_rte    _cl_convert_char3_sat_rte
+#define convert_uchar3_sat_rte    _cl_convert_uchar3_sat_rte
+#define convert_short3_sat_rte    _cl_convert_short3_sat_rte
+#define convert_ushort3_sat_rte    _cl_convert_ushort3_sat_rte
+#define convert_int3_sat_rte    _cl_convert_int3_sat_rte
+#define convert_uint3_sat_rte    _cl_convert_uint3_sat_rte
+#define convert_long3_sat_rte    _cl_convert_long3_sat_rte
+#define convert_ulong3_sat_rte    _cl_convert_ulong3_sat_rte
+#define convert_float3_sat_rte    _cl_convert_float3_sat_rte
+#define convert_double3_sat_rte    _cl_convert_double3_sat_rte
+#define convert_char3_sat_rtz    _cl_convert_char3_sat_rtz
+#define convert_uchar3_sat_rtz    _cl_convert_uchar3_sat_rtz
+#define convert_short3_sat_rtz    _cl_convert_short3_sat_rtz
+#define convert_ushort3_sat_rtz    _cl_convert_ushort3_sat_rtz
+#define convert_int3_sat_rtz    _cl_convert_int3_sat_rtz
+#define convert_uint3_sat_rtz    _cl_convert_uint3_sat_rtz
+#define convert_long3_sat_rtz    _cl_convert_long3_sat_rtz
+#define convert_ulong3_sat_rtz    _cl_convert_ulong3_sat_rtz
+#define convert_float3_sat_rtz    _cl_convert_float3_sat_rtz
+#define convert_double3_sat_rtz    _cl_convert_double3_sat_rtz
+#define convert_char3_sat_rtp    _cl_convert_char3_sat_rtp
+#define convert_uchar3_sat_rtp    _cl_convert_uchar3_sat_rtp
+#define convert_short3_sat_rtp    _cl_convert_short3_sat_rtp
+#define convert_ushort3_sat_rtp    _cl_convert_ushort3_sat_rtp
+#define convert_int3_sat_rtp    _cl_convert_int3_sat_rtp
+#define convert_uint3_sat_rtp    _cl_convert_uint3_sat_rtp
+#define convert_long3_sat_rtp    _cl_convert_long3_sat_rtp
+#define convert_ulong3_sat_rtp    _cl_convert_ulong3_sat_rtp
+#define convert_float3_sat_rtp    _cl_convert_float3_sat_rtp
+#define convert_double3_sat_rtp    _cl_convert_double3_sat_rtp
+#define convert_char3_sat_rtn    _cl_convert_char3_sat_rtn
+#define convert_uchar3_sat_rtn    _cl_convert_uchar3_sat_rtn
+#define convert_short3_sat_rtn    _cl_convert_short3_sat_rtn
+#define convert_ushort3_sat_rtn    _cl_convert_ushort3_sat_rtn
+#define convert_int3_sat_rtn    _cl_convert_int3_sat_rtn
+#define convert_uint3_sat_rtn    _cl_convert_uint3_sat_rtn
+#define convert_long3_sat_rtn    _cl_convert_long3_sat_rtn
+#define convert_ulong3_sat_rtn    _cl_convert_ulong3_sat_rtn
+#define convert_float3_sat_rtn    _cl_convert_float3_sat_rtn
+#define convert_double3_sat_rtn    _cl_convert_double3_sat_rtn
+
+#define  vload4   _cl_vload4
+#define  vstore4  _cl_vstore4
+#define  vload_half4   _cl_vload_half4
+#define  vstore_half4  _cl_vstore_half4
+#define  vloada_half4   _cl_vloada_half4
+#define  vstorea_half4  _cl_vstorea_half4
+#define  vload_half4_rte   _cl_vload_half4_rte
+#define  vstore_half4_rte  _cl_vstore_half4_rte
+#define  vloada_half4_rte   _cl_vloada_half4_rte
+#define  vstorea_half4_rte  _cl_vstorea_half4_rte
+#define  vload_half4_rtz   _cl_vload_half4_rtz
+#define  vstore_half4_rtz  _cl_vstore_half4_rtz
+#define  vloada_half4_rtz   _cl_vloada_half4_rtz
+#define  vstorea_half4_rtz  _cl_vstorea_half4_rtz
+#define  vload_half4_rtp   _cl_vload_half4_rtp
+#define  vstore_half4_rtp  _cl_vstore_half4_rtp
+#define  vloada_half4_rtp   _cl_vloada_half4_rtp
+#define  vstorea_half4_rtp  _cl_vstorea_half4_rtp
+#define  vload_half4_rtn   _cl_vload_half4_rtn
+#define  vstore_half4_rtn  _cl_vstore_half4_rtn
+#define  vloada_half4_rtn   _cl_vloada_half4_rtn
+#define  vstorea_half4_rtn  _cl_vstorea_half4_rtn
+#define convert_char4    _cl_convert_char4
+#define convert_uchar4    _cl_convert_uchar4
+#define convert_short4    _cl_convert_short4
+#define convert_ushort4    _cl_convert_ushort4
+#define convert_int4    _cl_convert_int4
+#define convert_uint4    _cl_convert_uint4
+#define convert_long4    _cl_convert_long4
+#define convert_ulong4    _cl_convert_ulong4
+#define convert_float4    _cl_convert_float4
+#define convert_double4    _cl_convert_double4
+#define convert_char4_rte    _cl_convert_char4_rte
+#define convert_uchar4_rte    _cl_convert_uchar4_rte
+#define convert_short4_rte    _cl_convert_short4_rte
+#define convert_ushort4_rte    _cl_convert_ushort4_rte
+#define convert_int4_rte    _cl_convert_int4_rte
+#define convert_uint4_rte    _cl_convert_uint4_rte
+#define convert_long4_rte    _cl_convert_long4_rte
+#define convert_ulong4_rte    _cl_convert_ulong4_rte
+#define convert_float4_rte    _cl_convert_float4_rte
+#define convert_double4_rte    _cl_convert_double4_rte
+#define convert_char4_rtz    _cl_convert_char4_rtz
+#define convert_uchar4_rtz    _cl_convert_uchar4_rtz
+#define convert_short4_rtz    _cl_convert_short4_rtz
+#define convert_ushort4_rtz    _cl_convert_ushort4_rtz
+#define convert_int4_rtz    _cl_convert_int4_rtz
+#define convert_uint4_rtz    _cl_convert_uint4_rtz
+#define convert_long4_rtz    _cl_convert_long4_rtz
+#define convert_ulong4_rtz    _cl_convert_ulong4_rtz
+#define convert_float4_rtz    _cl_convert_float4_rtz
+#define convert_double4_rtz    _cl_convert_double4_rtz
+#define convert_char4_rtp    _cl_convert_char4_rtp
+#define convert_uchar4_rtp    _cl_convert_uchar4_rtp
+#define convert_short4_rtp    _cl_convert_short4_rtp
+#define convert_ushort4_rtp    _cl_convert_ushort4_rtp
+#define convert_int4_rtp    _cl_convert_int4_rtp
+#define convert_uint4_rtp    _cl_convert_uint4_rtp
+#define convert_long4_rtp    _cl_convert_long4_rtp
+#define convert_ulong4_rtp    _cl_convert_ulong4_rtp
+#define convert_float4_rtp    _cl_convert_float4_rtp
+#define convert_double4_rtp    _cl_convert_double4_rtp
+#define convert_char4_rtn    _cl_convert_char4_rtn
+#define convert_uchar4_rtn    _cl_convert_uchar4_rtn
+#define convert_short4_rtn    _cl_convert_short4_rtn
+#define convert_ushort4_rtn    _cl_convert_ushort4_rtn
+#define convert_int4_rtn    _cl_convert_int4_rtn
+#define convert_uint4_rtn    _cl_convert_uint4_rtn
+#define convert_long4_rtn    _cl_convert_long4_rtn
+#define convert_ulong4_rtn    _cl_convert_ulong4_rtn
+#define convert_float4_rtn    _cl_convert_float4_rtn
+#define convert_double4_rtn    _cl_convert_double4_rtn
+#define convert_char4_sat    _cl_convert_char4_sat
+#define convert_uchar4_sat    _cl_convert_uchar4_sat
+#define convert_short4_sat    _cl_convert_short4_sat
+#define convert_ushort4_sat    _cl_convert_ushort4_sat
+#define convert_int4_sat    _cl_convert_int4_sat
+#define convert_uint4_sat    _cl_convert_uint4_sat
+#define convert_long4_sat    _cl_convert_long4_sat
+#define convert_ulong4_sat    _cl_convert_ulong4_sat
+#define convert_float4_sat    _cl_convert_float4_sat
+#define convert_double4_sat    _cl_convert_double4_sat
+#define convert_char4_sat_rte    _cl_convert_char4_sat_rte
+#define convert_uchar4_sat_rte    _cl_convert_uchar4_sat_rte
+#define convert_short4_sat_rte    _cl_convert_short4_sat_rte
+#define convert_ushort4_sat_rte    _cl_convert_ushort4_sat_rte
+#define convert_int4_sat_rte    _cl_convert_int4_sat_rte
+#define convert_uint4_sat_rte    _cl_convert_uint4_sat_rte
+#define convert_long4_sat_rte    _cl_convert_long4_sat_rte
+#define convert_ulong4_sat_rte    _cl_convert_ulong4_sat_rte
+#define convert_float4_sat_rte    _cl_convert_float4_sat_rte
+#define convert_double4_sat_rte    _cl_convert_double4_sat_rte
+#define convert_char4_sat_rtz    _cl_convert_char4_sat_rtz
+#define convert_uchar4_sat_rtz    _cl_convert_uchar4_sat_rtz
+#define convert_short4_sat_rtz    _cl_convert_short4_sat_rtz
+#define convert_ushort4_sat_rtz    _cl_convert_ushort4_sat_rtz
+#define convert_int4_sat_rtz    _cl_convert_int4_sat_rtz
+#define convert_uint4_sat_rtz    _cl_convert_uint4_sat_rtz
+#define convert_long4_sat_rtz    _cl_convert_long4_sat_rtz
+#define convert_ulong4_sat_rtz    _cl_convert_ulong4_sat_rtz
+#define convert_float4_sat_rtz    _cl_convert_float4_sat_rtz
+#define convert_double4_sat_rtz    _cl_convert_double4_sat_rtz
+#define convert_char4_sat_rtp    _cl_convert_char4_sat_rtp
+#define convert_uchar4_sat_rtp    _cl_convert_uchar4_sat_rtp
+#define convert_short4_sat_rtp    _cl_convert_short4_sat_rtp
+#define convert_ushort4_sat_rtp    _cl_convert_ushort4_sat_rtp
+#define convert_int4_sat_rtp    _cl_convert_int4_sat_rtp
+#define convert_uint4_sat_rtp    _cl_convert_uint4_sat_rtp
+#define convert_long4_sat_rtp    _cl_convert_long4_sat_rtp
+#define convert_ulong4_sat_rtp    _cl_convert_ulong4_sat_rtp
+#define convert_float4_sat_rtp    _cl_convert_float4_sat_rtp
+#define convert_double4_sat_rtp    _cl_convert_double4_sat_rtp
+#define convert_char4_sat_rtn    _cl_convert_char4_sat_rtn
+#define convert_uchar4_sat_rtn    _cl_convert_uchar4_sat_rtn
+#define convert_short4_sat_rtn    _cl_convert_short4_sat_rtn
+#define convert_ushort4_sat_rtn    _cl_convert_ushort4_sat_rtn
+#define convert_int4_sat_rtn    _cl_convert_int4_sat_rtn
+#define convert_uint4_sat_rtn    _cl_convert_uint4_sat_rtn
+#define convert_long4_sat_rtn    _cl_convert_long4_sat_rtn
+#define convert_ulong4_sat_rtn    _cl_convert_ulong4_sat_rtn
+#define convert_float4_sat_rtn    _cl_convert_float4_sat_rtn
+#define convert_double4_sat_rtn    _cl_convert_double4_sat_rtn
+
+#define  vload8   _cl_vload8
+#define  vstore8  _cl_vstore8
+#define  vload_half8   _cl_vload_half8
+#define  vstore_half8  _cl_vstore_half8
+#define  vloada_half8   _cl_vloada_half8
+#define  vstorea_half8  _cl_vstorea_half8
+#define  vload_half8_rte   _cl_vload_half8_rte
+#define  vstore_half8_rte  _cl_vstore_half8_rte
+#define  vloada_half8_rte   _cl_vloada_half8_rte
+#define  vstorea_half8_rte  _cl_vstorea_half8_rte
+#define  vload_half8_rtz   _cl_vload_half8_rtz
+#define  vstore_half8_rtz  _cl_vstore_half8_rtz
+#define  vloada_half8_rtz   _cl_vloada_half8_rtz
+#define  vstorea_half8_rtz  _cl_vstorea_half8_rtz
+#define  vload_half8_rtp   _cl_vload_half8_rtp
+#define  vstore_half8_rtp  _cl_vstore_half8_rtp
+#define  vloada_half8_rtp   _cl_vloada_half8_rtp
+#define  vstorea_half8_rtp  _cl_vstorea_half8_rtp
+#define  vload_half8_rtn   _cl_vload_half8_rtn
+#define  vstore_half8_rtn  _cl_vstore_half8_rtn
+#define  vloada_half8_rtn   _cl_vloada_half8_rtn
+#define  vstorea_half8_rtn  _cl_vstorea_half8_rtn
+#define convert_char8    _cl_convert_char8
+#define convert_uchar8    _cl_convert_uchar8
+#define convert_short8    _cl_convert_short8
+#define convert_ushort8    _cl_convert_ushort8
+#define convert_int8    _cl_convert_int8
+#define convert_uint8    _cl_convert_uint8
+#define convert_long8    _cl_convert_long8
+#define convert_ulong8    _cl_convert_ulong8
+#define convert_float8    _cl_convert_float8
+#define convert_double8    _cl_convert_double8
+#define convert_char8_rte    _cl_convert_char8_rte
+#define convert_uchar8_rte    _cl_convert_uchar8_rte
+#define convert_short8_rte    _cl_convert_short8_rte
+#define convert_ushort8_rte    _cl_convert_ushort8_rte
+#define convert_int8_rte    _cl_convert_int8_rte
+#define convert_uint8_rte    _cl_convert_uint8_rte
+#define convert_long8_rte    _cl_convert_long8_rte
+#define convert_ulong8_rte    _cl_convert_ulong8_rte
+#define convert_float8_rte    _cl_convert_float8_rte
+#define convert_double8_rte    _cl_convert_double8_rte
+#define convert_char8_rtz    _cl_convert_char8_rtz
+#define convert_uchar8_rtz    _cl_convert_uchar8_rtz
+#define convert_short8_rtz    _cl_convert_short8_rtz
+#define convert_ushort8_rtz    _cl_convert_ushort8_rtz
+#define convert_int8_rtz    _cl_convert_int8_rtz
+#define convert_uint8_rtz    _cl_convert_uint8_rtz
+#define convert_long8_rtz    _cl_convert_long8_rtz
+#define convert_ulong8_rtz    _cl_convert_ulong8_rtz
+#define convert_float8_rtz    _cl_convert_float8_rtz
+#define convert_double8_rtz    _cl_convert_double8_rtz
+#define convert_char8_rtp    _cl_convert_char8_rtp
+#define convert_uchar8_rtp    _cl_convert_uchar8_rtp
+#define convert_short8_rtp    _cl_convert_short8_rtp
+#define convert_ushort8_rtp    _cl_convert_ushort8_rtp
+#define convert_int8_rtp    _cl_convert_int8_rtp
+#define convert_uint8_rtp    _cl_convert_uint8_rtp
+#define convert_long8_rtp    _cl_convert_long8_rtp
+#define convert_ulong8_rtp    _cl_convert_ulong8_rtp
+#define convert_float8_rtp    _cl_convert_float8_rtp
+#define convert_double8_rtp    _cl_convert_double8_rtp
+#define convert_char8_rtn    _cl_convert_char8_rtn
+#define convert_uchar8_rtn    _cl_convert_uchar8_rtn
+#define convert_short8_rtn    _cl_convert_short8_rtn
+#define convert_ushort8_rtn    _cl_convert_ushort8_rtn
+#define convert_int8_rtn    _cl_convert_int8_rtn
+#define convert_uint8_rtn    _cl_convert_uint8_rtn
+#define convert_long8_rtn    _cl_convert_long8_rtn
+#define convert_ulong8_rtn    _cl_convert_ulong8_rtn
+#define convert_float8_rtn    _cl_convert_float8_rtn
+#define convert_double8_rtn    _cl_convert_double8_rtn
+#define convert_char8_sat    _cl_convert_char8_sat
+#define convert_uchar8_sat    _cl_convert_uchar8_sat
+#define convert_short8_sat    _cl_convert_short8_sat
+#define convert_ushort8_sat    _cl_convert_ushort8_sat
+#define convert_int8_sat    _cl_convert_int8_sat
+#define convert_uint8_sat    _cl_convert_uint8_sat
+#define convert_long8_sat    _cl_convert_long8_sat
+#define convert_ulong8_sat    _cl_convert_ulong8_sat
+#define convert_float8_sat    _cl_convert_float8_sat
+#define convert_double8_sat    _cl_convert_double8_sat
+#define convert_char8_sat_rte    _cl_convert_char8_sat_rte
+#define convert_uchar8_sat_rte    _cl_convert_uchar8_sat_rte
+#define convert_short8_sat_rte    _cl_convert_short8_sat_rte
+#define convert_ushort8_sat_rte    _cl_convert_ushort8_sat_rte
+#define convert_int8_sat_rte    _cl_convert_int8_sat_rte
+#define convert_uint8_sat_rte    _cl_convert_uint8_sat_rte
+#define convert_long8_sat_rte    _cl_convert_long8_sat_rte
+#define convert_ulong8_sat_rte    _cl_convert_ulong8_sat_rte
+#define convert_float8_sat_rte    _cl_convert_float8_sat_rte
+#define convert_double8_sat_rte    _cl_convert_double8_sat_rte
+#define convert_char8_sat_rtz    _cl_convert_char8_sat_rtz
+#define convert_uchar8_sat_rtz    _cl_convert_uchar8_sat_rtz
+#define convert_short8_sat_rtz    _cl_convert_short8_sat_rtz
+#define convert_ushort8_sat_rtz    _cl_convert_ushort8_sat_rtz
+#define convert_int8_sat_rtz    _cl_convert_int8_sat_rtz
+#define convert_uint8_sat_rtz    _cl_convert_uint8_sat_rtz
+#define convert_long8_sat_rtz    _cl_convert_long8_sat_rtz
+#define convert_ulong8_sat_rtz    _cl_convert_ulong8_sat_rtz
+#define convert_float8_sat_rtz    _cl_convert_float8_sat_rtz
+#define convert_double8_sat_rtz    _cl_convert_double8_sat_rtz
+#define convert_char8_sat_rtp    _cl_convert_char8_sat_rtp
+#define convert_uchar8_sat_rtp    _cl_convert_uchar8_sat_rtp
+#define convert_short8_sat_rtp    _cl_convert_short8_sat_rtp
+#define convert_ushort8_sat_rtp    _cl_convert_ushort8_sat_rtp
+#define convert_int8_sat_rtp    _cl_convert_int8_sat_rtp
+#define convert_uint8_sat_rtp    _cl_convert_uint8_sat_rtp
+#define convert_long8_sat_rtp    _cl_convert_long8_sat_rtp
+#define convert_ulong8_sat_rtp    _cl_convert_ulong8_sat_rtp
+#define convert_float8_sat_rtp    _cl_convert_float8_sat_rtp
+#define convert_double8_sat_rtp    _cl_convert_double8_sat_rtp
+#define convert_char8_sat_rtn    _cl_convert_char8_sat_rtn
+#define convert_uchar8_sat_rtn    _cl_convert_uchar8_sat_rtn
+#define convert_short8_sat_rtn    _cl_convert_short8_sat_rtn
+#define convert_ushort8_sat_rtn    _cl_convert_ushort8_sat_rtn
+#define convert_int8_sat_rtn    _cl_convert_int8_sat_rtn
+#define convert_uint8_sat_rtn    _cl_convert_uint8_sat_rtn
+#define convert_long8_sat_rtn    _cl_convert_long8_sat_rtn
+#define convert_ulong8_sat_rtn    _cl_convert_ulong8_sat_rtn
+#define convert_float8_sat_rtn    _cl_convert_float8_sat_rtn
+#define convert_double8_sat_rtn    _cl_convert_double8_sat_rtn
+
+#define  vload16   _cl_vload16
+#define  vstore16  _cl_vstore16
+#define  vload_half16   _cl_vload_half16
+#define  vstore_half16  _cl_vstore_half16
+#define  vloada_half16   _cl_vloada_half16
+#define  vstorea_half16  _cl_vstorea_half16
+#define  vload_half16_rte   _cl_vload_half16_rte
+#define  vstore_half16_rte  _cl_vstore_half16_rte
+#define  vloada_half16_rte   _cl_vloada_half16_rte
+#define  vstorea_half16_rte  _cl_vstorea_half16_rte
+#define  vload_half16_rtz   _cl_vload_half16_rtz
+#define  vstore_half16_rtz  _cl_vstore_half16_rtz
+#define  vloada_half16_rtz   _cl_vloada_half16_rtz
+#define  vstorea_half16_rtz  _cl_vstorea_half16_rtz
+#define  vload_half16_rtp   _cl_vload_half16_rtp
+#define  vstore_half16_rtp  _cl_vstore_half16_rtp
+#define  vloada_half16_rtp   _cl_vloada_half16_rtp
+#define  vstorea_half16_rtp  _cl_vstorea_half16_rtp
+#define  vload_half16_rtn   _cl_vload_half16_rtn
+#define  vstore_half16_rtn  _cl_vstore_half16_rtn
+#define  vloada_half16_rtn   _cl_vloada_half16_rtn
+#define  vstorea_half16_rtn  _cl_vstorea_half16_rtn
+#define convert_char16    _cl_convert_char16
+#define convert_uchar16    _cl_convert_uchar16
+#define convert_short16    _cl_convert_short16
+#define convert_ushort16    _cl_convert_ushort16
+#define convert_int16    _cl_convert_int16
+#define convert_uint16    _cl_convert_uint16
+#define convert_long16    _cl_convert_long16
+#define convert_ulong16    _cl_convert_ulong16
+#define convert_float16    _cl_convert_float16
+#define convert_double16    _cl_convert_double16
+#define convert_char16_rte    _cl_convert_char16_rte
+#define convert_uchar16_rte    _cl_convert_uchar16_rte
+#define convert_short16_rte    _cl_convert_short16_rte
+#define convert_ushort16_rte    _cl_convert_ushort16_rte
+#define convert_int16_rte    _cl_convert_int16_rte
+#define convert_uint16_rte    _cl_convert_uint16_rte
+#define convert_long16_rte    _cl_convert_long16_rte
+#define convert_ulong16_rte    _cl_convert_ulong16_rte
+#define convert_float16_rte    _cl_convert_float16_rte
+#define convert_double16_rte    _cl_convert_double16_rte
+#define convert_char16_rtz    _cl_convert_char16_rtz
+#define convert_uchar16_rtz    _cl_convert_uchar16_rtz
+#define convert_short16_rtz    _cl_convert_short16_rtz
+#define convert_ushort16_rtz    _cl_convert_ushort16_rtz
+#define convert_int16_rtz    _cl_convert_int16_rtz
+#define convert_uint16_rtz    _cl_convert_uint16_rtz
+#define convert_long16_rtz    _cl_convert_long16_rtz
+#define convert_ulong16_rtz    _cl_convert_ulong16_rtz
+#define convert_float16_rtz    _cl_convert_float16_rtz
+#define convert_double16_rtz    _cl_convert_double16_rtz
+#define convert_char16_rtp    _cl_convert_char16_rtp
+#define convert_uchar16_rtp    _cl_convert_uchar16_rtp
+#define convert_short16_rtp    _cl_convert_short16_rtp
+#define convert_ushort16_rtp    _cl_convert_ushort16_rtp
+#define convert_int16_rtp    _cl_convert_int16_rtp
+#define convert_uint16_rtp    _cl_convert_uint16_rtp
+#define convert_long16_rtp    _cl_convert_long16_rtp
+#define convert_ulong16_rtp    _cl_convert_ulong16_rtp
+#define convert_float16_rtp    _cl_convert_float16_rtp
+#define convert_double16_rtp    _cl_convert_double16_rtp
+#define convert_char16_rtn    _cl_convert_char16_rtn
+#define convert_uchar16_rtn    _cl_convert_uchar16_rtn
+#define convert_short16_rtn    _cl_convert_short16_rtn
+#define convert_ushort16_rtn    _cl_convert_ushort16_rtn
+#define convert_int16_rtn    _cl_convert_int16_rtn
+#define convert_uint16_rtn    _cl_convert_uint16_rtn
+#define convert_long16_rtn    _cl_convert_long16_rtn
+#define convert_ulong16_rtn    _cl_convert_ulong16_rtn
+#define convert_float16_rtn    _cl_convert_float16_rtn
+#define convert_double16_rtn    _cl_convert_double16_rtn
+#define convert_char16_sat    _cl_convert_char16_sat
+#define convert_uchar16_sat    _cl_convert_uchar16_sat
+#define convert_short16_sat    _cl_convert_short16_sat
+#define convert_ushort16_sat    _cl_convert_ushort16_sat
+#define convert_int16_sat    _cl_convert_int16_sat
+#define convert_uint16_sat    _cl_convert_uint16_sat
+#define convert_long16_sat    _cl_convert_long16_sat
+#define convert_ulong16_sat    _cl_convert_ulong16_sat
+#define convert_float16_sat    _cl_convert_float16_sat
+#define convert_double16_sat    _cl_convert_double16_sat
+#define convert_char16_sat_rte    _cl_convert_char16_sat_rte
+#define convert_uchar16_sat_rte    _cl_convert_uchar16_sat_rte
+#define convert_short16_sat_rte    _cl_convert_short16_sat_rte
+#define convert_ushort16_sat_rte    _cl_convert_ushort16_sat_rte
+#define convert_int16_sat_rte    _cl_convert_int16_sat_rte
+#define convert_uint16_sat_rte    _cl_convert_uint16_sat_rte
+#define convert_long16_sat_rte    _cl_convert_long16_sat_rte
+#define convert_ulong16_sat_rte    _cl_convert_ulong16_sat_rte
+#define convert_float16_sat_rte    _cl_convert_float16_sat_rte
+#define convert_double16_sat_rte    _cl_convert_double16_sat_rte
+#define convert_char16_sat_rtz    _cl_convert_char16_sat_rtz
+#define convert_uchar16_sat_rtz    _cl_convert_uchar16_sat_rtz
+#define convert_short16_sat_rtz    _cl_convert_short16_sat_rtz
+#define convert_ushort16_sat_rtz    _cl_convert_ushort16_sat_rtz
+#define convert_int16_sat_rtz    _cl_convert_int16_sat_rtz
+#define convert_uint16_sat_rtz    _cl_convert_uint16_sat_rtz
+#define convert_long16_sat_rtz    _cl_convert_long16_sat_rtz
+#define convert_ulong16_sat_rtz    _cl_convert_ulong16_sat_rtz
+#define convert_float16_sat_rtz    _cl_convert_float16_sat_rtz
+#define convert_double16_sat_rtz    _cl_convert_double16_sat_rtz
+#define convert_char16_sat_rtp    _cl_convert_char16_sat_rtp
+#define convert_uchar16_sat_rtp    _cl_convert_uchar16_sat_rtp
+#define convert_short16_sat_rtp    _cl_convert_short16_sat_rtp
+#define convert_ushort16_sat_rtp    _cl_convert_ushort16_sat_rtp
+#define convert_int16_sat_rtp    _cl_convert_int16_sat_rtp
+#define convert_uint16_sat_rtp    _cl_convert_uint16_sat_rtp
+#define convert_long16_sat_rtp    _cl_convert_long16_sat_rtp
+#define convert_ulong16_sat_rtp    _cl_convert_ulong16_sat_rtp
+#define convert_float16_sat_rtp    _cl_convert_float16_sat_rtp
+#define convert_double16_sat_rtp    _cl_convert_double16_sat_rtp
+#define convert_char16_sat_rtn    _cl_convert_char16_sat_rtn
+#define convert_uchar16_sat_rtn    _cl_convert_uchar16_sat_rtn
+#define convert_short16_sat_rtn    _cl_convert_short16_sat_rtn
+#define convert_ushort16_sat_rtn    _cl_convert_ushort16_sat_rtn
+#define convert_int16_sat_rtn    _cl_convert_int16_sat_rtn
+#define convert_uint16_sat_rtn    _cl_convert_uint16_sat_rtn
+#define convert_long16_sat_rtn    _cl_convert_long16_sat_rtn
+#define convert_ulong16_sat_rtn    _cl_convert_ulong16_sat_rtn
+#define convert_float16_sat_rtn    _cl_convert_float16_sat_rtn
+#define convert_double16_sat_rtn    _cl_convert_double16_sat_rtn
+
+#define convert_half    _cl_convert_half
+#define convert_half_rte    _cl_convert_half_rte
+#define convert_half_rtz    _cl_convert_half_rtz
+#define convert_half_rtp    _cl_convert_half_rtp
+#define convert_half_rtn    _cl_convert_half_rtn
+#define convert_half_sat    _cl_convert_half._sat
+#define convert_half_sat_rte    _cl_convert_half_sat_rte
+#define convert_half_sat_rtz    _cl_convert_half_sat_rtz
+#define convert_half_sat_rtp    _cl_convert_half_sat_rtp
+#define convert_half_sat_rtn    _cl_convert_half_sat_rtn
+
+#define convert_half2    _cl_convert_half2
+#define convert_half2_rte    _cl_convert_half2_rte
+#define convert_half2_rtz    _cl_convert_half2_rtz
+#define convert_half2_rtp    _cl_convert_half2_rtp
+#define convert_half2_rtn    _cl_convert_half2_rtn
+#define convert_half2_sat    _cl_convert_half2._sat
+#define convert_half2_sat_rte    _cl_convert_half2_sat_rte
+#define convert_half2_sat_rtz    _cl_convert_half2_sat_rtz
+#define convert_half2_sat_rtp    _cl_convert_half2_sat_rtp
+#define convert_half2_sat_rtn    _cl_convert_half2_sat_rtn
+
+#define convert_half3    _cl_convert_half3
+#define convert_half3_rte    _cl_convert_half3_rte
+#define convert_half3_rtz    _cl_convert_half3_rtz
+#define convert_half3_rtp    _cl_convert_half3_rtp
+#define convert_half3_rtn    _cl_convert_half3_rtn
+#define convert_half3_sat    _cl_convert_half3._sat
+#define convert_half3_sat_rte    _cl_convert_half3_sat_rte
+#define convert_half3_sat_rtz    _cl_convert_half3_sat_rtz
+#define convert_half3_sat_rtp    _cl_convert_half3_sat_rtp
+#define convert_half3_sat_rtn    _cl_convert_half3_sat_rtn
+
+#define convert_half4    _cl_convert_half4
+#define convert_half4_rte    _cl_convert_half4_rte
+#define convert_half4_rtz    _cl_convert_half4_rtz
+#define convert_half4_rtp    _cl_convert_half4_rtp
+#define convert_half4_rtn    _cl_convert_half4_rtn
+#define convert_half4_sat    _cl_convert_half4._sat
+#define convert_half4_sat_rte    _cl_convert_half4_sat_rte
+#define convert_half4_sat_rtz    _cl_convert_half4_sat_rtz
+#define convert_half4_sat_rtp    _cl_convert_half4_sat_rtp
+#define convert_half4_sat_rtn    _cl_convert_half4_sat_rtn
+
+#define convert_half8    _cl_convert_half8
+#define convert_half8_rte    _cl_convert_half8_rte
+#define convert_half8_rtz    _cl_convert_half8_rtz
+#define convert_half8_rtp    _cl_convert_half8_rtp
+#define convert_half8_rtn    _cl_convert_half8_rtn
+#define convert_half8_sat    _cl_convert_half8._sat
+#define convert_half8_sat_rte    _cl_convert_half8_sat_rte
+#define convert_half8_sat_rtz    _cl_convert_half8_sat_rtz
+#define convert_half8_sat_rtp    _cl_convert_half8_sat_rtp
+#define convert_half8_sat_rtn    _cl_convert_half8_sat_rtn
+
+#define convert_half16    _cl_convert_half16
+#define convert_half16_rte    _cl_convert_half16_rte
+#define convert_half16_rtz    _cl_convert_half16_rtz
+#define convert_half16_rtp    _cl_convert_half16_rtp
+#define convert_half16_rtn    _cl_convert_half16_rtn
+#define convert_half16_sat    _cl_convert_half16._sat
+#define convert_half16_sat_rte    _cl_convert_half16_sat_rte
+#define convert_half16_sat_rtz    _cl_convert_half16_sat_rtz
+#define convert_half16_sat_rtp    _cl_convert_half16_sat_rtp
+#define convert_half16_sat_rtn    _cl_convert_half16_sat_rtn
+
+
+#define atomic_add     _cl_atomic_add
+#define atomic_sub     _cl_atomic_sub
+#define atomic_xchg    _cl_atomic_xchg
+#define atomic_inc     _cl_atomic_inc
+#define atomic_dec     _cl_atomic_dec
+#define atomic_cmpxchg _cl_atomic_cmpxchg
+#define atomic_min     _cl_atomic_min
+#define atomic_max     _cl_atomic_max
+#define atomic_and     _cl_atomic_and
+#define atomic_or      _cl_atomic_or
+#define atomic_xor     _cl_atomic_xor
+
+#define atom_add     _cl_atom_add
+#define atom_sub     _cl_atom_sub
+#define atom_xchg    _cl_atom_xchg
+#define atom_inc     _cl_atom_inc
+#define atom_dec     _cl_atom_dec
+#define atom_cmpxchg _cl_atom_cmpxchg
+#define atom_min     _cl_atom_min
+#define atom_max     _cl_atom_max
+#define atom_and     _cl_atom_and
+#define atom_or      _cl_atom_or
+#define atom_xor     _cl_atom_xor
+
+#define  atomic_init    _cl_atomic_init
+#define  atomic_flag_test_and_set_explicit    _cl_atomic_flag_test_and_set_explicit
+#define  atomic_flag_test_and_set    _cl_atomic_flag_test_and_set
+#define  atomic_flag_clear_explicit    _cl_atomic_flag_clear_explicit
+#define  atomic_flag_clear    _cl_atomic_flag_clear
+#define  atomic_store_explicit    _cl_atomic_store_explicit
+#define  atomic_store    _cl_atomic_store
+#define  atomic_load_explicit    _cl_atomic_load_explicit
+#define  atomic_load    _cl_atomic_load
+#define  atomic_exchange_explicit    _cl_atomic_exchange_explicit
+#define  atomic_exchange    _cl_atomic_exchange
+#define  atomic_compare_exchange_strong_explicit    _cl_atomic_compare_exchange_strong_explicit
+#define  atomic_compare_exchange_strong    _cl_atomic_compare_exchange_strong
+#define  atomic_compare_exchange_weak_explicit    _cl_atomic_compare_exchange_weak_explicit
+#define  atomic_compare_exchange_weak    _cl_atomic_compare_exchange_weak
+#define  atomic_fetch_add_explicit    _cl_atomic_fetch_add_explicit
+#define  atomic_fetch_add    _cl_atomic_fetch_add
+#define  atomic_fetch_sub_explicit    _cl_atomic_fetch_sub_explicit
+#define  atomic_fetch_sub    _cl_atomic_fetch_sub
+#define  atomic_fetch_or_explicit    _cl_atomic_fetch_or_explicit
+#define  atomic_fetch_or    _cl_atomic_fetch_or
+#define  atomic_fetch_xor_explicit    _cl_atomic_fetch_xor_explicit
+#define  atomic_fetch_xor    _cl_atomic_fetch_xor
+#define  atomic_fetch_and_explicit    _cl_atomic_fetch_and_explicit
+#define  atomic_fetch_and    _cl_atomic_fetch_and
+#define  atomic_fetch_min_explicit    _cl_atomic_fetch_min_explicit
+#define  atomic_fetch_min    _cl_atomic_fetch_min
+#define  atomic_fetch_max_explicit    _cl_atomic_fetch_max_explicit
+#define  atomic_fetch_max    _cl_atomic_fetch_max
+
+#define read_mem_fence     _cl_read_mem_fence
+#define write_mem_fence    _cl_write_mem_fence
+#define mem_fence          _cl_mem_fence
+#define work_group_barrier _cl_work_group_barrier
+#define atomic_work_item_fence _cl_atomic_work_item_fence
+#define wait_group_events  _cl_wait_group_events
+
+#define get_image_array_size _cl_get_image_array_size
+#define get_image_channel_data_type _cl_get_image_channel_data_type
+#define get_image_channel_order _cl_get_image_channel_order
+#define get_image_dim _cl_get_image_dim
+#define get_image_depth _cl_get_image_depth
+#define get_image_height _cl_get_image_height
+#define get_image_width _cl_get_image_width
+#define read_imageui _cl_read_imageui
+#define read_imagei _cl_read_imagei
+#define read_imagef _cl_read_imagef
+#define read_imageh _cl_read_imageh
+#define write_imageui _cl_write_imageui
+#define write_imagei _cl_write_imagei
+#define write_imagef _cl_write_imagef
+#define write_imageh _cl_write_imageh
+
+#define get_sub_group_size _cl_get_sub_group_size
+#define get_max_sub_group_size _cl_get_max_sub_group_size
+#define get_num_sub_groups _cl_get_num_sub_groups
+#define get_enqueued_num_sub_groups _cl_get_enqueued_num_sub_groups
+#define get_sub_group_id _cl_get_sub_group_id
+#define get_sub_group_local_id _cl_get_sub_group_local_id
+#define sub_group_ballot _cl_sub_group_ballot
+#define sub_group_broadcast _cl_sub_group_broadcast
+#define sub_group_barrier _cl_sub_group_barrier
+#define sub_group_any _cl_sub_group_any
+#define sub_group_all _cl_sub_group_all
+#define sub_group_reduce_add _cl_sub_group_reduce_add
+#define sub_group_reduce_min _cl_sub_group_reduce_min
+#define sub_group_reduce_max _cl_sub_group_reduce_max
+#define sub_group_shuffle _cl_sub_group_shuffle
+#define sub_group_shuffle_xor _cl_sub_group_shuffle_xor
+#define sub_group_shuffle_up _cl_sub_group_shuffle_up
+#define sub_group_shuffle_down _cl_sub_group_shuffle_down
+#define intel_sub_group_shuffle _cl_intel_sub_group_shuffle
+#define intel_sub_group_shuffle_xor _cl_intel_sub_group_shuffle_xor
+#define intel_sub_group_shuffle_up _cl_intel_sub_group_shuffle_up
+#define intel_sub_group_shuffle_down _cl_intel_sub_group_shuffle_down
+#define sub_group_scan_inclusive_add _cl_sub_group_scan_inclusive_add
+#define sub_group_scan_inclusive_min _cl_sub_group_scan_inclusive_min
+#define sub_group_scan_inclusive_max _cl_sub_group_scan_inclusive_max
+#define sub_group_scan_exclusive_add _cl_sub_group_scan_exclusive_add
+#define sub_group_scan_exclusive_min _cl_sub_group_scan_exclusive_min
+#define sub_group_scan_exclusive_max _cl_sub_group_scan_exclusive_max
+
+#define intel_sub_group_block_read _cl_intel_sub_group_block_read
+#define intel_sub_group_block_read2 _cl_intel_sub_group_block_read2
+#define intel_sub_group_block_read4 _cl_intel_sub_group_block_read4
+#define intel_sub_group_block_read8 _cl_intel_sub_group_block_read8
+#define intel_sub_group_block_read_uc _cl_intel_sub_group_block_read_uc
+#define intel_sub_group_block_read_uc2 _cl_intel_sub_group_block_read_uc2
+#define intel_sub_group_block_read_uc4 _cl_intel_sub_group_block_read_uc4
+#define intel_sub_group_block_read_uc8 _cl_intel_sub_group_block_read_uc8
+#define intel_sub_group_block_read_uc16 _cl_intel_sub_group_block_read_uc16
+#define intel_sub_group_block_read_us _cl_intel_sub_group_block_read_us
+#define intel_sub_group_block_read_us2 _cl_intel_sub_group_block_read_us2
+#define intel_sub_group_block_read_us4 _cl_intel_sub_group_block_read_us4
+#define intel_sub_group_block_read_us8 _cl_intel_sub_group_block_read_us8
+#define intel_sub_group_block_read_ui _cl_intel_sub_group_block_read_ui
+#define intel_sub_group_block_read_ui2 _cl_intel_sub_group_block_read_ui2
+#define intel_sub_group_block_read_ui4 _cl_intel_sub_group_block_read_ui4
+#define intel_sub_group_block_read_ui8 _cl_intel_sub_group_block_read_ui8
+
+#define intel_sub_group_block_write _cl_intel_sub_group_block_write
+#define intel_sub_group_block_write2 _cl_intel_sub_group_block_write2
+#define intel_sub_group_block_write4 _cl_intel_sub_group_block_write4
+#define intel_sub_group_block_write8 _cl_intel_sub_group_block_write8
+#define intel_sub_group_block_write_uc _cl_intel_sub_group_block_write_uc
+#define intel_sub_group_block_write_uc2 _cl_intel_sub_group_block_write_uc2
+#define intel_sub_group_block_write_uc4 _cl_intel_sub_group_block_write_uc4
+#define intel_sub_group_block_write_uc8 _cl_intel_sub_group_block_write_uc8
+#define intel_sub_group_block_write_uc16 _cl_intel_sub_group_block_write_uc16
+#define intel_sub_group_block_write_us _cl_intel_sub_group_block_write_us
+#define intel_sub_group_block_write_us2 _cl_intel_sub_group_block_write_us2
+#define intel_sub_group_block_write_us4 _cl_intel_sub_group_block_write_us4
+#define intel_sub_group_block_write_us8 _cl_intel_sub_group_block_write_us8
+#define intel_sub_group_block_write_ui _cl_intel_sub_group_block_write_ui
+#define intel_sub_group_block_write_ui2 _cl_intel_sub_group_block_write_ui2
+#define intel_sub_group_block_write_ui4 _cl_intel_sub_group_block_write_ui4
+#define intel_sub_group_block_write_ui8 _cl_intel_sub_group_block_write_ui8
+
+#define bitfield_insert _cl_bitfield_insert
+#define bitfield_extract_signed _cl_bitfield_extract_signed
+#define bitfield_extract_unsigned _cl_bitfield_extract_unsigned
+
+#define dot _cl_dot
+#define dot_acc_sat _cl_dot_acc_sat
+#define dot_4x8packed_uu_uint _cl_dot_4x8packed_uu_uint
+#define dot_4x8packed_ss_int _cl_dot_4x8packed_ss_int
+#define dot_4x8packed_us_int _cl_dot_4x8packed_us_int
+#define dot_4x8packed_su_int _cl_dot_4x8packed_su_int
+#define dot_acc_sat_4x8packed_uu_uint _cl_dot_acc_sat_4x8packed_uu_uint
+#define dot_acc_sat_4x8packed_su_int _cl_dot_acc_sat_4x8packed_su_int
+#define dot_acc_sat_4x8packed_us_int _cl_dot_acc_sat_4x8packed_us_int
+#define dot_acc_sat_4x8packed_ss_int _cl_dot_acc_sat_4x8packed_ss_int
+
+#define clock_read_device _cl_clock_read_device
+#define clock_read_work_group _cl_clock_read_work_group
+#define clock_read_sub_group _cl_clock_read_sub_group
+#define clock_read_hilo_device _cl_clock_read_hilo_device
+#define clock_read_hilo_work_group _cl_clock_read_hilo_work_group
+#define clock_read_hilo_sub_group _cl_clock_read_hilo_sub_group
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/_clang_opencl.h b/drivers/pocl-gen7/share/pocl/include/_clang_opencl.h
new file mode 100644
index 0000000..3c0c885
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/_clang_opencl.h
@@ -0,0 +1,770 @@
+/* This file adds declarations missing from opencl-c.h.
+
+   Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT
+                 2024 Pekka Jääskeläinen / Intel Finland Oy
+   Copyright (c) 2017 Michal Babej / Tampere University of Technology
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to
+   deal in the Software without restriction, including without limitation the
+   rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+   sell copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+   IN THE SOFTWARE.
+*/
+
+#ifndef _CLANG_OPENCL_H
+#define _CLANG_OPENCL_H
+
+#ifndef SKIP_HEADER_INCLUDE
+/* Use the declarations shipped with Clang. */
+#ifndef _OPENCL_H_
+/* Check for _OPENCL_H already here because the kernel compiler loads the
+   header beforehand, but cannot find the file due to include paths not
+   set up. */
+#include "opencl-c.h"
+#endif
+#endif
+
+/* We can include this header directly (to patch up opencl-c.h without
+   including _kernel.h, thus need to define the attribute macros here. */
+#ifndef _CL_OVERLOADABLE
+
+#if __has_attribute(__overloadable__)
+#  define _CL_OVERLOADABLE __attribute__((__overloadable__))
+#else
+#  define _CL_OVERLOADABLE
+#endif
+
+#endif
+
+#ifndef _CL_READNONE
+
+#if __has_attribute(__const__)
+#  define _CL_READNONE __attribute__((__const__))
+#else
+#  define _CL_READNONE
+#endif
+
+#endif
+
+#ifndef _CL_CONV
+
+#if __has_attribute(__convergent__)
+#  define _CL_CONV __attribute__((__convergent__))
+#else
+#  define _CL_CONV
+#endif
+
+#endif
+
+/* Some of the geometric builtins are defined only up to 4 vectors, but we
+   implement them all: */
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+half _CL_OVERLOADABLE _CL_READNONE length (half8 p);
+half _CL_OVERLOADABLE _CL_READNONE length (half16 p);
+
+half _CL_OVERLOADABLE _CL_READNONE fast_length (half8 p);
+half _CL_OVERLOADABLE _CL_READNONE fast_length (half16 p);
+
+half8 _CL_OVERLOADABLE _CL_READNONE normalize (half8 p);
+half16 _CL_OVERLOADABLE _CL_READNONE normalize (half16 p);
+
+half8 _CL_OVERLOADABLE _CL_READNONE fast_normalize (half8 p);
+half16 _CL_OVERLOADABLE _CL_READNONE fast_normalize (half16 p);
+
+half _CL_OVERLOADABLE _CL_READNONE dot (half8 p0, half8 p1);
+half _CL_OVERLOADABLE _CL_READNONE dot (half16 p0, half16 p1);
+#endif
+
+float _CL_OVERLOADABLE _CL_READNONE length (float8 p);
+float _CL_OVERLOADABLE _CL_READNONE length (float16 p);
+
+float _CL_OVERLOADABLE _CL_READNONE fast_length (float8 p);
+float _CL_OVERLOADABLE _CL_READNONE fast_length (float16 p);
+
+float8 _CL_OVERLOADABLE _CL_READNONE normalize (float8 p);
+float16 _CL_OVERLOADABLE _CL_READNONE normalize (float16 p);
+
+float8 _CL_OVERLOADABLE _CL_READNONE fast_normalize (float8 p);
+float16 _CL_OVERLOADABLE _CL_READNONE fast_normalize (float16 p);
+
+float _CL_OVERLOADABLE _CL_READNONE dot (float8 p0, float8 p1);
+float _CL_OVERLOADABLE _CL_READNONE dot (float16 p0, float16 p1);
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+double _CL_OVERLOADABLE _CL_READNONE length (double8 p);
+double _CL_OVERLOADABLE _CL_READNONE length (double16 p);
+
+double _CL_OVERLOADABLE _CL_READNONE fast_length (double p);
+double _CL_OVERLOADABLE _CL_READNONE fast_length (double2 p);
+double _CL_OVERLOADABLE _CL_READNONE fast_length (double3 p);
+double _CL_OVERLOADABLE _CL_READNONE fast_length (double4 p);
+double _CL_OVERLOADABLE _CL_READNONE fast_length (double8 p);
+double _CL_OVERLOADABLE _CL_READNONE fast_length (double16 p);
+
+double8 _CL_OVERLOADABLE _CL_READNONE normalize (double8 p);
+double16 _CL_OVERLOADABLE _CL_READNONE normalize (double16 p);
+
+double8 _CL_OVERLOADABLE _CL_READNONE fast_normalize (double8 p);
+double16 _CL_OVERLOADABLE _CL_READNONE fast_normalize (double16 p);
+
+double _CL_OVERLOADABLE _CL_READNONE dot (double8 p0, double8 p1);
+double _CL_OVERLOADABLE _CL_READNONE dot (double16 p0, double16 p1);
+
+#endif
+
+#if defined(cl_khr_kernel_clock)
+
+#if defined(__opencl_c_kernel_clock_scope_device)
+ulong _CL_OVERLOADABLE _CL_CONV clock_read_device(void);
+uint2 _CL_OVERLOADABLE _CL_CONV clock_read_hilo_device(void);
+#endif // __opencl_c_kernel_clock_scope_device
+
+#if defined(__opencl_c_kernel_clock_scope_work_group)
+ulong _CL_OVERLOADABLE _CL_CONV clock_read_work_group(void);
+uint2 _CL_OVERLOADABLE _CL_CONV clock_read_hilo_work_group(void);
+#endif // __opencl_c_kernel_clock_scope_work_group
+
+#if defined(__opencl_c_kernel_clock_scope_sub_group)
+ulong _CL_OVERLOADABLE _CL_CONV clock_read_sub_group(void);
+uint2 _CL_OVERLOADABLE _CL_CONV clock_read_hilo_sub_group(void);
+#endif // __opencl_c_kernel_clock_scope_sub_group
+
+#endif // cl_khr_kernel_clock
+
+/**************************************************************************/
+
+#if defined(cl_intel_subgroups_char)
+/* The char version is missing from opencl-c.h */
+char _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (char, uint sub_group_local_id);
+char2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (char2, uint sub_group_local_id);
+char3 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (char3, uint sub_group_local_id);
+char4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (char4, uint sub_group_local_id);
+char8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (char8, uint sub_group_local_id);
+
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (uchar, uint sub_group_local_id);
+uchar2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (uchar2, uint sub_group_local_id);
+uchar3 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (uchar3, uint sub_group_local_id);
+uchar4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (uchar4, uint sub_group_local_id);
+uchar8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (uchar8, uint sub_group_local_id);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char, uint);
+char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char2, uint);
+char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char3, uint);
+char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char4, uint);
+char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char8, uint);
+char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char16, uint);
+
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar, uint);
+uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar2, uint);
+uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar3, uint);
+uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar4, uint);
+uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar8, uint);
+uchar16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar16, uint);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char cur,
+                                                                 char next,
+                                                                 uint);
+char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char2 cur,
+                                                                  char2 next,
+                                                                  uint);
+char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char3 cur,
+                                                                  char3 next,
+                                                                  uint);
+char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char4 cur,
+                                                                  char4 next,
+                                                                  uint);
+char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char8 cur,
+                                                                  char8 next,
+                                                                  uint);
+char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char16 cur,
+                                                                   char16 next,
+                                                                   uint);
+
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar cur,
+                                                                  uchar next,
+                                                                  uint);
+uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar2 cur,
+                                                                   uchar2 next,
+                                                                   uint);
+uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar3 cur,
+                                                                   uchar3 next,
+                                                                   uint);
+uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar4 cur,
+                                                                   uchar4 next,
+                                                                   uint);
+uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar8 cur,
+                                                                   uchar8 next,
+                                                                   uint);
+uchar16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_shuffle_down (uchar16 cur, uchar16 next, uint);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char cur,
+                                                               char next,
+                                                               uint);
+char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char2 cur,
+                                                                char2 next,
+                                                                uint);
+char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char3 cur,
+                                                                char3 next,
+                                                                uint);
+char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char4 cur,
+                                                                char4 next,
+                                                                uint);
+char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char8 cur,
+                                                                char8 next,
+                                                                uint);
+char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char16 cur,
+                                                                 char16 next,
+                                                                 uint);
+
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar cur,
+                                                                uchar next,
+                                                                uint);
+uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar2 cur,
+                                                                 uchar2 next,
+                                                                 uint);
+uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar3 cur,
+                                                                 uchar3 next,
+                                                                 uint);
+uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar4 cur,
+                                                                 uchar4 next,
+                                                                 uint);
+uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar8 cur,
+                                                                 uchar8 next,
+                                                                 uint);
+uchar16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar16 cur,
+                                                                  uchar16 next,
+                                                                  uint);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char, uint);
+char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char2, uint);
+char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char3, uint);
+char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char4, uint);
+char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char8, uint);
+char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char16,
+                                                                  uint);
+
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar, uint);
+uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar2,
+                                                                  uint);
+uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar3,
+                                                                  uint);
+uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar4,
+                                                                  uint);
+uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar8,
+                                                                  uint);
+uchar16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar16,
+                                                                   uint);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (char x);
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (uchar x);
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (char x);
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (uchar x);
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (char x);
+uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (uchar x);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_add (char x);
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_exclusive_add (uchar x);
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_min (char x);
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_exclusive_min (uchar x);
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_max (char x);
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_exclusive_max (uchar x);
+
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_add (char x);
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_inclusive_add (uchar x);
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_min (char x);
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_inclusive_min (uchar x);
+char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_max (char x);
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_inclusive_max (uchar x);
+
+#if defined(__opencl_c_images)
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc (read_only image2d_t, int2);
+uchar2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc2 (read_only image2d_t, int2);
+uchar4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc4 (read_only image2d_t, int2);
+uchar8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc8 (read_only image2d_t, int2);
+uchar16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc16 (read_only image2d_t, int2);
+
+#if defined(__opencl_c_read_write_images)
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc (read_write image2d_t, int2);
+uchar2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc2 (read_write image2d_t, int2);
+uchar4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc4 (read_write image2d_t, int2);
+uchar8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc8 (read_write image2d_t, int2);
+uchar16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc16 (read_write image2d_t, int2);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc (const global uchar *p);
+uchar2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc2 (const global uchar *p);
+uchar4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc4 (const global uchar *p);
+uchar8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc8 (const global uchar *p);
+uchar16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc16 (const global uchar *p);
+
+uchar _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc (const local uchar *p);
+uchar2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc2 (const local uchar *p);
+uchar4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc4 (const local uchar *p);
+uchar8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc8 (const local uchar *p);
+uchar16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_uc16 (const local uchar *p);
+
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc (global uchar *p,
+                                                      uchar data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc2 (global uchar *p,
+                                                       uchar2 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc4 (global uchar *p,
+                                                       uchar4 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc8 (global uchar *p,
+                                                       uchar8 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc16 (global uchar *p,
+                                                       uchar16 data);
+
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc (local uchar *p,
+                                                      uchar data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc2 (local uchar *p,
+                                                       uchar2 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc4 (local uchar *p,
+                                                       uchar4 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc8 (local uchar *p,
+                                                       uchar8 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc16 (local uchar *p,
+                                                       uchar16 data);
+
+#if defined(__opencl_c_images)
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc (write_only image2d_t, int2, uchar);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc2 (write_only image2d_t, int2, uchar2);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc4 (write_only image2d_t, int2, uchar4);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc8 (write_only image2d_t, int2, uchar8);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc16 (write_only image2d_t, int2, uchar16);
+
+#if defined(__opencl_c_read_write_images)
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc (read_write image2d_t, int2, uchar);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc2 (read_write image2d_t, int2, uchar2);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc4 (read_write image2d_t, int2, uchar4);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc8 (read_write image2d_t, int2, uchar8);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_uc16 (read_write image2d_t, int2, uchar16);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+#endif // cl_intel_subgroups_char
+
+/**************************************************************************/
+
+#if defined(cl_intel_subgroups_short)
+/* The short version is missing from opencl-c.h */
+short _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (short, uint sub_group_local_id);
+short2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (short2, uint sub_group_local_id);
+short3 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (short3, uint sub_group_local_id);
+short4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (short4, uint sub_group_local_id);
+short8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (short8, uint sub_group_local_id);
+
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (ushort, uint sub_group_local_id);
+ushort2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (ushort2, uint sub_group_local_id);
+ushort3 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (ushort3, uint sub_group_local_id);
+ushort4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (ushort4, uint sub_group_local_id);
+ushort8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_broadcast (ushort8, uint sub_group_local_id);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short, uint);
+short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short2, uint);
+short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short3, uint);
+short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short4, uint);
+short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short8, uint);
+short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short16, uint);
+
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort, uint);
+ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort2, uint);
+ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort3, uint);
+ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort4, uint);
+ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort8, uint);
+ushort16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort16, uint);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short cur,
+                                                                 short next,
+                                                                 uint);
+short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short2 cur,
+                                                                  short2 next,
+                                                                  uint);
+short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short3 cur,
+                                                                  short3 next,
+                                                                  uint);
+short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short4 cur,
+                                                                  short4 next,
+                                                                  uint);
+short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short8 cur,
+                                                                  short8 next,
+                                                                  uint);
+short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short16 cur,
+                                                                   short16 next,
+                                                                   uint);
+
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort cur,
+                                                                  ushort next,
+                                                                  uint);
+ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort2 cur,
+                                                                   ushort2 next,
+                                                                   uint);
+ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort3 cur,
+                                                                   ushort3 next,
+                                                                   uint);
+ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort4 cur,
+                                                                   ushort4 next,
+                                                                   uint);
+ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort8 cur,
+                                                                   ushort8 next,
+                                                                   uint);
+ushort16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_shuffle_down (ushort16 cur, ushort16 next, uint);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short cur,
+                                                               short next,
+                                                               uint);
+short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short2 cur,
+                                                                short2 next,
+                                                                uint);
+short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short3 cur,
+                                                                short3 next,
+                                                                uint);
+short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short4 cur,
+                                                                short4 next,
+                                                                uint);
+short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short8 cur,
+                                                                short8 next,
+                                                                uint);
+short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short16 cur,
+                                                                 short16 next,
+                                                                 uint);
+
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort cur,
+                                                                ushort next,
+                                                                uint);
+ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort2 cur,
+                                                                 ushort2 next,
+                                                                 uint);
+ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort3 cur,
+                                                                 ushort3 next,
+                                                                 uint);
+ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort4 cur,
+                                                                 ushort4 next,
+                                                                 uint);
+ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort8 cur,
+                                                                 ushort8 next,
+                                                                 uint);
+ushort16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort16 cur,
+                                                                  ushort16 next,
+                                                                  uint);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short, uint);
+short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short2, uint);
+short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short3, uint);
+short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short4, uint);
+short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short8, uint);
+short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short16,
+                                                                  uint);
+
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort, uint);
+ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort2,
+                                                                  uint);
+ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort3,
+                                                                  uint);
+ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort4,
+                                                                  uint);
+ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort8,
+                                                                  uint);
+ushort16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort16,
+                                                                   uint);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (short x);
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (ushort x);
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (short x);
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (ushort x);
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (short x);
+ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (ushort x);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_add (short x);
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_exclusive_add (ushort x);
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_min (short x);
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_exclusive_min (ushort x);
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_max (short x);
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_exclusive_max (ushort x);
+
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_add (short x);
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_inclusive_add (ushort x);
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_min (short x);
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_inclusive_min (ushort x);
+short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_max (short x);
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_scan_inclusive_max (ushort x);
+
+#if defined(__opencl_c_images)
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us (read_only image2d_t, int2);
+ushort2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us2 (read_only image2d_t, int2);
+ushort4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us4 (read_only image2d_t, int2);
+ushort8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us8 (read_only image2d_t, int2);
+ushort16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us16 (read_only image2d_t, int2);
+
+#if defined(__opencl_c_read_write_images)
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us (read_write image2d_t, int2);
+ushort2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us2 (read_write image2d_t, int2);
+ushort4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us4 (read_write image2d_t, int2);
+ushort8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us8 (read_write image2d_t, int2);
+ushort16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us16 (read_write image2d_t, int2);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us (const global ushort *p);
+ushort2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us2 (const global ushort *p);
+ushort4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us4 (const global ushort *p);
+ushort8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us8 (const global ushort *p);
+ushort16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us16 (const global ushort *p);
+
+ushort _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us (const local ushort *p);
+ushort2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us2 (const local ushort *p);
+ushort4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us4 (const local ushort *p);
+ushort8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us8 (const local ushort *p);
+ushort16 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_us16 (const local ushort *p);
+
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us (global ushort *p,
+                                                      ushort data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us2 (global ushort *p,
+                                                       ushort2 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us4 (global ushort *p,
+                                                       ushort4 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us8 (global ushort *p,
+                                                       ushort8 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us16 (global ushort *p,
+                                                       ushort16 data);
+
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us (local ushort *p,
+                                                      ushort data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us2 (local ushort *p,
+                                                       ushort2 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us4 (local ushort *p,
+                                                       ushort4 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us8 (local ushort *p,
+                                                       ushort8 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us16 (local ushort *p,
+                                                       ushort16 data);
+
+#if defined(__opencl_c_images)
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us (write_only image2d_t, int2, ushort);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us2 (write_only image2d_t, int2, ushort2);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us4 (write_only image2d_t, int2, ushort4);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us8 (write_only image2d_t, int2, ushort8);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us16 (write_only image2d_t, int2, ushort16);
+
+#if defined(__opencl_c_read_write_images)
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us (read_write image2d_t, int2, ushort);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us2 (read_write image2d_t, int2, ushort2);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us4 (read_write image2d_t, int2, ushort4);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us8 (read_write image2d_t, int2, ushort8);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_us16 (read_write image2d_t, int2, ushort16);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+#endif // cl_intel_subgroups_short
+
+/**************************************************************************/
+
+#if defined(cl_intel_subgroups_long)
+
+#if defined(__opencl_c_images)
+ulong _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul (read_only image2d_t, int2);
+ulong2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul2 (read_only image2d_t, int2);
+ulong4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul4 (read_only image2d_t, int2);
+ulong8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul8 (read_only image2d_t, int2);
+
+#if defined(__opencl_c_read_write_images)
+ulong _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul (read_write image2d_t, int2);
+ulong2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul2 (read_write image2d_t, int2);
+ulong4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul4 (read_write image2d_t, int2);
+ulong8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul8 (read_write image2d_t, int2);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+ulong _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul (const global ulong *p);
+ulong2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul2 (const global ulong *p);
+ulong4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul4 (const global ulong *p);
+ulong8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul8 (const global ulong *p);
+
+ulong _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul (const local ulong *p);
+ulong2 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul2 (const local ulong *p);
+ulong4 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul4 (const local ulong *p);
+ulong8 _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_read_ul8 (const local ulong *p);
+
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul (global ulong *p,
+                                                      ulong data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul2 (global ulong *p,
+                                                       ulong2 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul4 (global ulong *p,
+                                                       ulong4 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul8 (global ulong *p,
+                                                       ulong8 data);
+
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul (local ulong *p,
+                                                      ulong data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul2 (local ulong *p,
+                                                       ulong2 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul4 (local ulong *p,
+                                                       ulong4 data);
+void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul8 (local ulong *p,
+                                                       ulong8 data);
+
+#if defined(__opencl_c_images)
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul (write_only image2d_t, int2, ulong);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul2 (write_only image2d_t, int2, ulong2);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul4 (write_only image2d_t, int2, ulong4);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul8 (write_only image2d_t, int2, ulong8);
+
+#if defined(__opencl_c_read_write_images)
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul (read_write image2d_t, int2, ulong);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul2 (read_write image2d_t, int2, ulong2);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul4 (read_write image2d_t, int2, ulong4);
+void _CL_OVERLOADABLE _CL_CONV
+intel_sub_group_block_write_ul8 (read_write image2d_t, int2, ulong8);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+#endif // cl_intel_subgroups_long
+
+/**************************************************************************/
+
+#ifdef cl_intel_split_work_group_barrier
+void _CL_OVERLOADABLE
+intel_work_group_barrier_arrive (cl_mem_fence_flags flags);
+void _CL_OVERLOADABLE intel_work_group_barrier_wait (cl_mem_fence_flags flags);
+// For OpenCL C 2.0 or newer:
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+void _CL_OVERLOADABLE
+intel_work_group_barrier_arrive (cl_mem_fence_flags flags, memory_scope scope);
+void _CL_OVERLOADABLE intel_work_group_barrier_wait (cl_mem_fence_flags flags,
+                                                     memory_scope scope);
+#endif
+#endif // cl_intel_split_work_group_barrier
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/_enable_all_exts.h b/drivers/pocl-gen7/share/pocl/include/_enable_all_exts.h
new file mode 100644
index 0000000..64957e6
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/_enable_all_exts.h
@@ -0,0 +1,53 @@
+/* Enable all extensions known to pocl, which a device supports.
+ * This is required at the start of include/_kernel.h for prototypes,
+ * then at kernel lib compilation phase (because _kernel.h disables
+ * everything at the end).
+ */
+
+/* OpenCL 1.0-only extensions */
+
+#if (__OPENCL_C_VERSION__ < 110)
+
+#ifdef cl_khr_global_int32_base_atomics
+#  pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable
+#endif
+
+#ifdef cl_khr_global_int32_extended_atomics
+#  pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable
+#endif
+
+#ifdef cl_khr_local_int32_base_atomics
+#  pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable
+#endif
+
+#ifdef cl_khr_local_int32_extended_atomics
+#  pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable
+#endif
+
+#ifdef cl_khr_byte_addressable_store
+#  pragma OPENCL EXTENSION cl_khr_byte_addressable_store : enable
+#endif
+
+#endif
+
+
+/* all versions */
+#ifdef cl_khr_fp16
+#  pragma OPENCL EXTENSION cl_khr_fp16: enable
+#endif
+
+#ifdef cl_khr_fp64
+#  pragma OPENCL EXTENSION cl_khr_fp64: enable
+#endif
+
+#ifdef cl_khr_int64_base_atomics
+#  pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+#endif
+
+#ifdef cl_khr_int64_extended_atomics
+#  pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable
+#endif
+
+#ifdef cl_khr_3d_image_writes
+#  pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/_kernel.h b/drivers/pocl-gen7/share/pocl/include/_kernel.h
new file mode 100644
index 0000000..62f8f33
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/_kernel.h
@@ -0,0 +1,179 @@
+/* pocl/_kernel.h - OpenCL types and runtime library
+   functions declarations. This should be included only from OpenCL C files.
+
+   Copyright (c) 2011 Universidad Rey Juan Carlos
+   Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT
+   Copyright (c) 2011-2013 Erik Schnetter <eschnetter@perimeterinstitute.ca>
+                           Perimeter Institute for Theoretical Physics
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+*/
+
+/* If the -cl-std build option is not specified, the highest OpenCL C 1.x
+ * language version supported by each device is used as the version of
+ * OpenCL C when compiling the program for each device.
+ */
+#ifndef __OPENCL_C_VERSION__
+#define __OPENCL_C_VERSION__ 120
+#endif
+
+#if (__OPENCL_C_VERSION__ > 99)
+#define CL_VERSION_1_0 100
+#endif
+
+#if (__OPENCL_C_VERSION__ > 109)
+#define CL_VERSION_1_1 110
+#endif
+
+#if (__OPENCL_C_VERSION__ > 119)
+#define CL_VERSION_1_2 120
+#endif
+
+#if (__OPENCL_C_VERSION__ > 199)
+#define CL_VERSION_2_0 200
+#endif
+
+#include "_enable_all_exts.h"
+
+#include "_builtin_renames.h"
+
+/* Define some feature test macros to help write generic code. These are used
+ * mostly in _pocl_opencl.h header + some .cl files in kernel library */
+
+#ifdef cl_khr_int64
+#  define __IF_INT64(x) x
+#else
+#  define __IF_INT64(x)
+#endif
+#ifdef cl_khr_fp16
+#  define __IF_FP16(x) x
+#else
+#  define __IF_FP16(x)
+#endif
+#ifdef cl_khr_fp64
+#  define __IF_FP64(x) x
+#else
+#  define __IF_FP64(x)
+#endif
+#ifdef cl_khr_int64_base_atomics
+#define __IF_BA64(x) x
+#else
+#define __IF_BA64(x)
+#endif
+#ifdef cl_khr_int64_extended_atomics
+#define __IF_EA64(x) x
+#else
+#define __IF_EA64(x)
+#endif
+
+/****************************************************************************/
+
+/* Function/type attributes supported by Clang/SPIR */
+#if __has_attribute(__always_inline__)
+#  define _CL_ALWAYSINLINE __attribute__((__always_inline__))
+#else
+#  define _CL_ALWAYSINLINE
+#endif
+#if __has_attribute(__noinline__)
+#  define _CL_NOINLINE __attribute__((__noinline__))
+#else
+#  define _CL_NOINLINE
+#endif
+#if __has_attribute(__overloadable__)
+#  define _CL_OVERLOADABLE __attribute__((__overloadable__))
+#else
+#  define _CL_OVERLOADABLE
+#endif
+#if __has_attribute(__pure__)
+#  define _CL_READONLY __attribute__((__pure__))
+#else
+#  define _CL_READONLY
+#endif
+#if __has_attribute(__const__)
+#  define _CL_READNONE __attribute__((__const__))
+#else
+#  define _CL_READNONE
+#endif
+#if __has_attribute(convergent)
+#  define _CL_CONVERGENT __attribute__((convergent))
+#else
+#  define _CL_CONVERGENT
+#endif
+
+/****************************************************************************/
+
+/* A static assert statement to catch inconsistencies at build time */
+#if __has_extension(__c_static_assert__)
+#  define _CL_STATIC_ASSERT(_t, _x) _Static_assert(_x, #_t)
+#else
+#  define _CL_STATIC_ASSERT(_t, _x) typedef int __cl_ai##_t[(x) ? 1 : -1];
+#endif
+
+/****************************************************************************/
+
+#define IMG_RO_AQ __read_only
+#define IMG_WO_AQ __write_only
+
+#ifdef __opencl_c_read_write_images
+#define CLANG_HAS_RW_IMAGES
+#define IMG_RW_AQ __read_write
+#else
+#undef CLANG_HAS_RW_IMAGES
+#define IMG_RW_AQ __RW_IMAGES_UNSUPPORTED_BEFORE_CL_20
+#endif
+
+/****************************************************************************/
+/* use Clang opencl header for definitions. */
+
+#ifdef POCL_DEVICE_ADDRESS_BITS
+
+/* If we wish to override the Clang set __SIZE_TYPE__ for this target,
+   let's do it here so the opencl-c.h sets size_t to the wanted type. */
+
+#ifdef __SIZE_TYPE__
+#undef __SIZE_TYPE__
+#endif
+
+#if POCL_DEVICE_ADDRESS_BITS == 32
+#define __SIZE_TYPE__ uint
+#elif POCL_DEVICE_ADDRESS_BITS == 64
+#define __SIZE_TYPE__ ulong
+#else
+#error Unsupported POCL_DEVICE_ADDRESS_BITS value.
+#endif
+
+#endif
+
+#include "_clang_opencl.h"
+
+/****************************************************************************/
+
+/* GNU's libm seems to use INT_MIN here while the Clang's header uses
+   INT_MAX. Both are allowed by the OpenCL specs, but we want them to
+   be unified to avoid failing tests. */
+#undef FP_ILOGBNAN
+#undef FP_ILOGB0
+#define FP_ILOGB0    INT_MIN
+#define FP_ILOGBNAN  INT_MAX
+
+/****************************************************************************/
+
+#include "pocl_image_types.h"
+
+#pragma OPENCL EXTENSION all : disable
diff --git a/drivers/pocl-gen7/share/pocl/include/_kernel_c.h b/drivers/pocl-gen7/share/pocl/include/_kernel_c.h
new file mode 100644
index 0000000..807a75d
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/_kernel_c.h
@@ -0,0 +1,199 @@
+/* pocl/_kernel_c.h - C compatible OpenCL types and runtime library
+   functions declarations for kernel builtin implementations using C.
+
+   Copyright (c) 2011 Universidad Rey Juan Carlos
+   Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT
+   Copyright (c) 2011-2013 Erik Schnetter <eschnetter@perimeterinstitute.ca>
+                           Perimeter Institute for Theoretical Physics
+
+   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.
+*/
+/**
+ * Header that can be implemented in C compiled implementations of
+ * built-in functions to introduce the OpenCL C compatible types etc.
+ */
+#ifndef _KERNEL_C_H
+#define _KERNEL_C_H
+
+#include "pocl_types.h"
+
+/* cannot include "_builtin_renames.h" because it overrides some C/C++ macros,
+   but we need the prefixed functions in the builtin library */
+#define POCL_BUILTIN_PREFIX(FUNC) _cl_##FUNC
+
+#include "_kernel_constants.h"
+
+/* Function/type attributes supported by Clang/SPIR */
+#if __has_attribute(__always_inline__)
+#  define _CL_ALWAYSINLINE __attribute__((__always_inline__))
+#else
+#  define _CL_ALWAYSINLINE
+#endif
+#if __has_attribute(__noinline__)
+#  define _CL_NOINLINE __attribute__((__noinline__))
+#else
+#  define _CL_NOINLINE
+#endif
+#if __has_attribute(__overloadable__)
+#  define _CL_OVERLOADABLE __attribute__((__overloadable__))
+#else
+#  define _CL_OVERLOADABLE
+#endif
+#if __has_attribute(__pure__)
+#  define _CL_READONLY __attribute__((__pure__))
+#else
+#  define _CL_READONLY
+#endif
+#if __has_attribute(__const__)
+#  define _CL_READNONE __attribute__((__const__))
+#else
+#  define _CL_READNONE
+#endif
+#if __has_attribute(convergent)
+#  define _CL_CONVERGENT __attribute__((convergent))
+#else
+#  define _CL_CONVERGENT
+#endif
+#if __has_attribute(optnone)
+#define _CL_OPTNONE __attribute__ ((optnone))
+#else
+#define _CL_OPTNONE
+#endif
+
+typedef char char2  __attribute__((__ext_vector_type__(2)));
+typedef char char3  __attribute__((__ext_vector_type__(3)));
+typedef char char4  __attribute__((__ext_vector_type__(4)));
+typedef char char8  __attribute__((__ext_vector_type__(8)));
+typedef char char16 __attribute__((__ext_vector_type__(16)));
+
+typedef uchar uchar2  __attribute__((__ext_vector_type__(2)));
+typedef uchar uchar3  __attribute__((__ext_vector_type__(3)));
+typedef uchar uchar4  __attribute__((__ext_vector_type__(4)));
+typedef uchar uchar8  __attribute__((__ext_vector_type__(8)));
+typedef uchar uchar16 __attribute__((__ext_vector_type__(16)));
+
+typedef short short2  __attribute__((__ext_vector_type__(2)));
+typedef short short3  __attribute__((__ext_vector_type__(3)));
+typedef short short4  __attribute__((__ext_vector_type__(4)));
+typedef short short8  __attribute__((__ext_vector_type__(8)));
+typedef short short16 __attribute__((__ext_vector_type__(16)));
+
+typedef ushort ushort2  __attribute__((__ext_vector_type__(2)));
+typedef ushort ushort3  __attribute__((__ext_vector_type__(3)));
+typedef ushort ushort4  __attribute__((__ext_vector_type__(4)));
+typedef ushort ushort8  __attribute__((__ext_vector_type__(8)));
+typedef ushort ushort16 __attribute__((__ext_vector_type__(16)));
+
+typedef int int2  __attribute__((__ext_vector_type__(2)));
+typedef int int3  __attribute__((__ext_vector_type__(3)));
+typedef int int4  __attribute__((__ext_vector_type__(4)));
+typedef int int8  __attribute__((__ext_vector_type__(8)));
+typedef int int16 __attribute__((__ext_vector_type__(16)));
+
+typedef uint uint2  __attribute__((__ext_vector_type__(2)));
+typedef uint uint3  __attribute__((__ext_vector_type__(3)));
+typedef uint uint4  __attribute__((__ext_vector_type__(4)));
+typedef uint uint8  __attribute__((__ext_vector_type__(8)));
+typedef uint uint16 __attribute__((__ext_vector_type__(16)));
+
+#if defined(__CBUILD__) && defined(cl_khr_fp16)
+
+#ifdef _HAS_FLOAT16_TYPE
+typedef _Float16 half;
+#else
+typedef __fp16 half;
+#endif
+
+typedef half half2  __attribute__((__ext_vector_type__(2)));
+typedef half half3  __attribute__((__ext_vector_type__(3)));
+typedef half half4  __attribute__((__ext_vector_type__(4)));
+typedef half half8  __attribute__((__ext_vector_type__(8)));
+typedef half half16 __attribute__((__ext_vector_type__(16)));
+#endif
+
+typedef float float2  __attribute__((__ext_vector_type__(2)));
+typedef float float3  __attribute__((__ext_vector_type__(3)));
+typedef float float4  __attribute__((__ext_vector_type__(4)));
+typedef float float8  __attribute__((__ext_vector_type__(8)));
+typedef float float16 __attribute__((__ext_vector_type__(16)));
+
+#ifdef cl_khr_fp64
+#  ifndef __CBUILD__
+#    pragma OPENCL EXTENSION cl_khr_fp64 : enable
+#  endif
+typedef double double2  __attribute__((__ext_vector_type__(2)));
+typedef double double3  __attribute__((__ext_vector_type__(3)));
+typedef double double4  __attribute__((__ext_vector_type__(4)));
+typedef double double8  __attribute__((__ext_vector_type__(8)));
+typedef double double16 __attribute__((__ext_vector_type__(16)));
+#endif
+
+#ifdef cl_khr_int64
+typedef long long2  __attribute__((__ext_vector_type__(2)));
+typedef long long3  __attribute__((__ext_vector_type__(3)));
+typedef long long4  __attribute__((__ext_vector_type__(4)));
+typedef long long8  __attribute__((__ext_vector_type__(8)));
+typedef long long16 __attribute__((__ext_vector_type__(16)));
+
+typedef ulong ulong2  __attribute__((__ext_vector_type__(2)));
+typedef ulong ulong3  __attribute__((__ext_vector_type__(3)));
+typedef ulong ulong4  __attribute__((__ext_vector_type__(4)));
+typedef ulong ulong8  __attribute__((__ext_vector_type__(8)));
+typedef ulong ulong16 __attribute__((__ext_vector_type__(16)));
+#endif
+
+#if defined(__TCE__)
+
+#define POCL_ADDRESS_SPACE_PRIVATE 0
+#define POCL_ADDRESS_SPACE_GLOBAL 1
+#define POCL_ADDRESS_SPACE_LOCAL 3
+#define POCL_ADDRESS_SPACE_CONSTANT 2
+#define POCL_ADDRESS_SPACE_GENERIC 6
+
+#endif
+
+typedef uint cl_mem_fence_flags;
+
+/* Integer Constants */
+
+#if defined(__CBUILD__)
+
+#define CHAR_BIT  8
+#define CHAR_MAX  SCHAR_MAX
+#define CHAR_MIN  SCHAR_MIN
+#define INT_MAX   2147483647
+#define INT_MIN   (-2147483647 - 1)
+#ifdef cl_khr_int64
+#define LONG_MAX  0x7fffffffffffffffL
+#define LONG_MIN  (-0x7fffffffffffffffL - 1)
+#endif
+#define SCHAR_MAX 127
+#define SCHAR_MIN (-127 - 1)
+#define SHRT_MAX  32767
+#define SHRT_MIN  (-32767 - 1)
+#define UCHAR_MAX 255
+#define USHRT_MAX 65535
+#define UINT_MAX  0xffffffff
+#ifdef cl_khr_int64
+#define ULONG_MAX 0xffffffffffffffffUL
+#endif
+
+#endif /* __CBUILD__ */
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/_kernel_constants.h b/drivers/pocl-gen7/share/pocl/include/_kernel_constants.h
new file mode 100644
index 0000000..e45ebdb
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/_kernel_constants.h
@@ -0,0 +1,93 @@
+/* pocl/_kernel_constants.h - C compatible OpenCL types and runtime library
+   constants declarations.
+
+   Copyright (c) 2011 Universidad Rey Juan Carlos
+   Copyright (c) 2011-2013 Pekka Jääskeläinen / TUT
+   Copyright (c) 2011-2013 Erik Schnetter <eschnetter@perimeterinstitute.ca>
+                           Perimeter Institute for Theoretical Physics
+   
+   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.
+*/
+/**
+ * Header that can be implemented in C compiled implementations of
+ * built-in functions to introduce the OpenCL C compatible constants.
+ */
+#ifndef _KERNEL_CONSTANTS_H
+#define _KERNEL_CONSTANTS_H
+
+/* clang's header defines these */
+#ifndef _OPENCL_H_
+
+/* cl_channel_order */
+#define CLK_R                                        0x10B0
+#define CLK_A                                        0x10B1
+#define CLK_RG                                       0x10B2
+#define CLK_RA                                       0x10B3
+#define CLK_RGB                                      0x10B4
+#define CLK_RGBA                                     0x10B5
+#define CLK_BGRA                                     0x10B6
+#define CLK_ARGB                                     0x10B7
+#define CLK_INTENSITY                                0x10B8
+#define CLK_LUMINANCE                                0x10B9
+#define CLK_Rx                                       0x10BA
+#define CLK_RGx                                      0x10BB
+#define CLK_RGBx                                     0x10BC
+#define CLK_DEPTH                                    0x10BD
+#define CLK_DEPTH_STENCIL                            0x10BE
+
+/* cl_channel_type */
+#define CLK_SNORM_INT8                               0x10D0
+#define CLK_SNORM_INT16                              0x10D1
+#define CLK_UNORM_INT8                               0x10D2
+#define CLK_UNORM_INT16                              0x10D3
+#define CLK_UNORM_SHORT_565                          0x10D4
+#define CLK_UNORM_SHORT_555                          0x10D5
+#define CLK_UNORM_INT_101010                         0x10D6
+#define CLK_SIGNED_INT8                              0x10D7
+#define CLK_SIGNED_INT16                             0x10D8
+#define CLK_SIGNED_INT32                             0x10D9
+#define CLK_UNSIGNED_INT8                            0x10DA
+#define CLK_UNSIGNED_INT16                           0x10DB
+#define CLK_UNSIGNED_INT32                           0x10DC
+#define CLK_HALF_FLOAT                               0x10DD
+#define CLK_FLOAT                                    0x10DE
+#define CLK_UNORM_INT24                              0x10DF
+
+/* cl_addressing _mode */
+#define CLK_ADDRESS_NONE                            0x00
+#define CLK_ADDRESS_CLAMP_TO_EDGE                   0x02
+#define CLK_ADDRESS_CLAMP                           0x04
+#define CLK_ADDRESS_REPEAT                          0x06
+#define CLK_ADDRESS_MIRRORED_REPEAT                 0x08
+
+/* cl_sampler_info */
+#define CLK_NORMALIZED_COORDS_FALSE                 0x00
+#define CLK_NORMALIZED_COORDS_TRUE                  0x01
+
+/* filter_mode */
+#define CLK_FILTER_NEAREST                          0x10
+#define CLK_FILTER_LINEAR                           0x20
+
+/* barrier() flags */
+#define CLK_LOCAL_MEM_FENCE                         0x01
+#define CLK_GLOBAL_MEM_FENCE                        0x02
+
+#endif
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/opencl-c-base.h b/drivers/pocl-gen7/share/pocl/include/opencl-c-base.h
new file mode 100644
index 0000000..68daf0b
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/opencl-c-base.h
@@ -0,0 +1,830 @@
+//===----- opencl-c-base.h - OpenCL C language base definitions -----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _OPENCL_BASE_H_
+#define _OPENCL_BASE_H_
+
+// Define extension macros
+
+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
+// For SPIR and SPIR-V all extensions are supported.
+#if defined(__SPIR__) || defined(__SPIRV__)
+#define cl_khr_subgroup_extended_types 1
+#define cl_khr_subgroup_non_uniform_vote 1
+#define cl_khr_subgroup_ballot 1
+#define cl_khr_subgroup_non_uniform_arithmetic 1
+#define cl_khr_subgroup_shuffle 1
+#define cl_khr_subgroup_shuffle_relative 1
+#define cl_khr_subgroup_clustered_reduce 1
+#define cl_khr_subgroup_rotate 1
+#define cl_khr_extended_bit_ops 1
+#define cl_khr_integer_dot_product 1
+#define __opencl_c_integer_dot_product_input_4x8bit 1
+#define __opencl_c_integer_dot_product_input_4x8bit_packed 1
+#define cl_ext_float_atomics 1
+#ifdef cl_khr_fp16
+#define __opencl_c_ext_fp16_global_atomic_load_store 1
+#define __opencl_c_ext_fp16_local_atomic_load_store 1
+#define __opencl_c_ext_fp16_global_atomic_add 1
+#define __opencl_c_ext_fp16_local_atomic_add 1
+#define __opencl_c_ext_fp16_global_atomic_min_max 1
+#define __opencl_c_ext_fp16_local_atomic_min_max 1
+#endif
+#ifdef cl_khr_fp64
+#define __opencl_c_ext_fp64_global_atomic_add 1
+#define __opencl_c_ext_fp64_local_atomic_add 1
+#define __opencl_c_ext_fp64_global_atomic_min_max 1
+#define __opencl_c_ext_fp64_local_atomic_min_max 1
+#endif
+#define __opencl_c_ext_fp32_global_atomic_add 1
+#define __opencl_c_ext_fp32_local_atomic_add 1
+#define __opencl_c_ext_fp32_global_atomic_min_max 1
+#define __opencl_c_ext_fp32_local_atomic_min_max 1
+
+#endif // defined(__SPIR__) || defined(__SPIRV__)
+#endif // (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
+
+// Define feature macros for OpenCL C 2.0
+#if (__OPENCL_CPP_VERSION__ == 100 || __OPENCL_C_VERSION__ == 200)
+#define __opencl_c_pipes 1
+#define __opencl_c_generic_address_space 1
+#define __opencl_c_work_group_collective_functions 1
+#define __opencl_c_atomic_order_acq_rel 1
+#define __opencl_c_atomic_order_seq_cst 1
+#define __opencl_c_atomic_scope_device 1
+#define __opencl_c_atomic_scope_all_devices 1
+#define __opencl_c_device_enqueue 1
+#define __opencl_c_read_write_images 1
+#define __opencl_c_program_scope_global_variables 1
+#define __opencl_c_images 1
+#endif
+
+// Define header-only feature macros for OpenCL C 3.0.
+#if (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
+// For the SPIR and SPIR-V target all features are supported.
+#if defined(__SPIR__) || defined(__SPIRV__)
+#define __opencl_c_work_group_collective_functions 1
+#define __opencl_c_atomic_order_seq_cst 1
+#define __opencl_c_atomic_scope_device 1
+#define __opencl_c_atomic_scope_all_devices 1
+#define __opencl_c_read_write_images 1
+#endif // defined(__SPIR__)
+
+// Undefine any feature macros that have been explicitly disabled using
+// an __undef_<feature> macro.
+#ifdef __undef___opencl_c_work_group_collective_functions
+#undef __opencl_c_work_group_collective_functions
+#endif
+#ifdef __undef___opencl_c_atomic_order_seq_cst
+#undef __opencl_c_atomic_order_seq_cst
+#endif
+#ifdef __undef___opencl_c_atomic_scope_device
+#undef __opencl_c_atomic_scope_device
+#endif
+#ifdef __undef___opencl_c_atomic_scope_all_devices
+#undef __opencl_c_atomic_scope_all_devices
+#endif
+#ifdef __undef___opencl_c_read_write_images
+#undef __opencl_c_read_write_images
+#endif
+
+#endif // (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
+
+#if !defined(__opencl_c_generic_address_space)
+// Internal feature macro to provide named (global, local, private) address
+// space overloads for builtin functions that take a pointer argument.
+#define __opencl_c_named_address_space_builtins 1
+#endif // !defined(__opencl_c_generic_address_space)
+
+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || defined(__opencl_c_subgroups)
+// Internal feature macro to provide subgroup builtins.
+#define __opencl_subgroup_builtins 1
+#endif
+
+// built-in scalar data types:
+
+/**
+ * An unsigned 8-bit integer.
+ */
+typedef unsigned char uchar;
+
+/**
+ * An unsigned 16-bit integer.
+ */
+typedef unsigned short ushort;
+
+/**
+ * An unsigned 32-bit integer.
+ */
+typedef unsigned int uint;
+
+/**
+ * An unsigned 64-bit integer.
+ */
+typedef unsigned long ulong;
+
+/**
+ * The unsigned integer type of the result of the sizeof operator. This
+ * is a 32-bit unsigned integer if CL_DEVICE_ADDRESS_BITS
+ * defined in table 4.3 is 32-bits and is a 64-bit unsigned integer if
+ * CL_DEVICE_ADDRESS_BITS is 64-bits.
+ */
+typedef __SIZE_TYPE__ size_t;
+
+/**
+ * A signed integer type that is the result of subtracting two pointers.
+ * This is a 32-bit signed integer if CL_DEVICE_ADDRESS_BITS
+ * defined in table 4.3 is 32-bits and is a 64-bit signed integer if
+ * CL_DEVICE_ADDRESS_BITS is 64-bits.
+ */
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+
+/**
+ * A signed integer type with the property that any valid pointer to
+ * void can be converted to this type, then converted back to pointer
+ * to void, and the result will compare equal to the original pointer.
+ */
+typedef __INTPTR_TYPE__ intptr_t;
+
+/**
+ * An unsigned integer type with the property that any valid pointer to
+ * void can be converted to this type, then converted back to pointer
+ * to void, and the result will compare equal to the original pointer.
+ */
+typedef __UINTPTR_TYPE__ uintptr_t;
+
+// built-in vector data types:
+typedef char char2 __attribute__((ext_vector_type(2))) __attribute__((aligned(2)));
+typedef char char3 __attribute__((ext_vector_type(3))) __attribute__((aligned(4)));
+typedef char char4 __attribute__((ext_vector_type(4))) __attribute__((aligned(4)));
+typedef char char8 __attribute__((ext_vector_type(8))) __attribute__((aligned(8)));
+typedef char char16 __attribute__((ext_vector_type(16))) __attribute__((aligned(16)));
+
+typedef uchar uchar2 __attribute__((ext_vector_type(2))) __attribute__((aligned(2)));
+typedef uchar uchar3 __attribute__((ext_vector_type(3))) __attribute__((aligned(4)));
+typedef uchar uchar4 __attribute__((ext_vector_type(4))) __attribute__((aligned(4)));
+typedef uchar uchar8 __attribute__((ext_vector_type(8))) __attribute__((aligned(8)));
+typedef uchar uchar16 __attribute__((ext_vector_type(16))) __attribute__((aligned(16)));
+
+typedef short short2 __attribute__((ext_vector_type(2))) __attribute__((aligned(4)));
+typedef short short3 __attribute__((ext_vector_type(3))) __attribute__((aligned(8)));
+typedef short short4 __attribute__((ext_vector_type(4))) __attribute__((aligned(8)));
+typedef short short8 __attribute__((ext_vector_type(8))) __attribute__((aligned(16)));
+typedef short short16 __attribute__((ext_vector_type(16))) __attribute__((aligned(32)));
+
+typedef ushort ushort2 __attribute__((ext_vector_type(2))) __attribute__((aligned(4)));
+typedef ushort ushort3 __attribute__((ext_vector_type(3))) __attribute__((aligned(8)));
+typedef ushort ushort4 __attribute__((ext_vector_type(4))) __attribute__((aligned(8)));
+typedef ushort ushort8 __attribute__((ext_vector_type(8))) __attribute__((aligned(16)));
+typedef ushort ushort16 __attribute__((ext_vector_type(16))) __attribute__((aligned(32)));
+
+typedef int int2 __attribute__((ext_vector_type(2))) __attribute__((aligned(8)));
+typedef int int3 __attribute__((ext_vector_type(3))) __attribute__((aligned(16)));
+typedef int int4 __attribute__((ext_vector_type(4))) __attribute__((aligned(16)));
+typedef int int8 __attribute__((ext_vector_type(8))) __attribute__((aligned(32)));
+typedef int int16 __attribute__((ext_vector_type(16))) __attribute__((aligned(64)));
+
+typedef uint uint2 __attribute__((ext_vector_type(2))) __attribute__((aligned(8)));
+typedef uint uint3 __attribute__((ext_vector_type(3))) __attribute__((aligned(16)));
+typedef uint uint4 __attribute__((ext_vector_type(4))) __attribute__((aligned(16)));
+typedef uint uint8 __attribute__((ext_vector_type(8))) __attribute__((aligned(32)));
+typedef uint uint16 __attribute__((ext_vector_type(16))) __attribute__((aligned(64)));
+
+typedef long long2 __attribute__((ext_vector_type(2))) __attribute__((aligned(16)));
+typedef long long3 __attribute__((ext_vector_type(3))) __attribute__((aligned(32)));
+typedef long long4 __attribute__((ext_vector_type(4))) __attribute__((aligned(32)));
+typedef long long8 __attribute__((ext_vector_type(8))) __attribute__((aligned(64)));
+typedef long long16 __attribute__((ext_vector_type(16))) __attribute__((aligned(128)));
+
+typedef ulong ulong2 __attribute__((ext_vector_type(2))) __attribute__((aligned(16)));
+typedef ulong ulong3 __attribute__((ext_vector_type(3))) __attribute__((aligned(32)));
+typedef ulong ulong4 __attribute__((ext_vector_type(4))) __attribute__((aligned(32)));
+typedef ulong ulong8 __attribute__((ext_vector_type(8))) __attribute__((aligned(64)));
+typedef ulong ulong16 __attribute__((ext_vector_type(16))) __attribute__((aligned(128)));
+
+typedef float float2 __attribute__((ext_vector_type(2))) __attribute__((aligned(8)));
+typedef float float3 __attribute__((ext_vector_type(3))) __attribute__((aligned(16)));
+typedef float float4 __attribute__((ext_vector_type(4))) __attribute__((aligned(16)));
+typedef float float8 __attribute__((ext_vector_type(8))) __attribute__((aligned(32)));
+typedef float float16 __attribute__((ext_vector_type(16))) __attribute__((aligned(64)));
+
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+typedef half half2 __attribute__((ext_vector_type(2))) __attribute__((aligned(4)));
+typedef half half3 __attribute__((ext_vector_type(3))) __attribute__((aligned(8)));
+typedef half half4 __attribute__((ext_vector_type(4))) __attribute__((aligned(8)));
+typedef half half8 __attribute__((ext_vector_type(8))) __attribute__((aligned(16)));
+typedef half half16 __attribute__((ext_vector_type(16))) __attribute__((aligned(32)));
+#endif
+#ifdef cl_khr_fp64
+#if __OPENCL_C_VERSION__ < CL_VERSION_1_2
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+#endif
+typedef double double2 __attribute__((ext_vector_type(2))) __attribute__((aligned(16)));
+typedef double double3 __attribute__((ext_vector_type(3))) __attribute__((aligned(32)));
+typedef double double4 __attribute__((ext_vector_type(4))) __attribute__((aligned(32)));
+typedef double double8 __attribute__((ext_vector_type(8))) __attribute__((aligned(64)));
+typedef double double16 __attribute__((ext_vector_type(16))) __attribute__((aligned(128)));
+#endif
+
+
+// An internal alias for half, for use by OpenCLBuiltins.td.
+#define __half half
+
+#if defined(__OPENCL_CPP_VERSION__)
+#define NULL nullptr
+#elif defined(__OPENCL_C_VERSION__)
+#define NULL ((void*)0)
+#endif
+
+/**
+ * Value of maximum non-infinite single-precision floating-point
+ * number.
+ */
+#define MAXFLOAT 0x1.fffffep127f
+
+/**
+ * A positive float constant expression. HUGE_VALF evaluates
+ * to +infinity. Used as an error value returned by the built-in
+ * math functions.
+ */
+#define HUGE_VALF (__builtin_huge_valf())
+
+/**
+ * A positive double constant expression. HUGE_VAL evaluates
+ * to +infinity. Used as an error value returned by the built-in
+ * math functions.
+ */
+#define HUGE_VAL (__builtin_huge_val())
+
+/**
+ * A constant expression of type float representing positive or
+ * unsigned infinity.
+ */
+#define INFINITY (__builtin_inff())
+
+/**
+ * A constant expression of type float representing a quiet NaN.
+ */
+#define NAN as_float(INT_MAX)
+
+#define FP_ILOGB0    INT_MIN
+#define FP_ILOGBNAN  INT_MAX
+
+#define FLT_DIG 6
+#define FLT_MANT_DIG 24
+#define FLT_MAX_10_EXP +38
+#define FLT_MAX_EXP +128
+#define FLT_MIN_10_EXP -37
+#define FLT_MIN_EXP -125
+#define FLT_RADIX 2
+#define FLT_MAX 0x1.fffffep127f
+#define FLT_MIN 0x1.0p-126f
+#define FLT_EPSILON 0x1.0p-23f
+
+#define M_E_F         2.71828182845904523536028747135266250f
+#define M_LOG2E_F     1.44269504088896340735992468100189214f
+#define M_LOG10E_F    0.434294481903251827651128918916605082f
+#define M_LN2_F       0.693147180559945309417232121458176568f
+#define M_LN10_F      2.30258509299404568401799145468436421f
+#define M_PI_F        3.14159265358979323846264338327950288f
+#define M_PI_2_F      1.57079632679489661923132169163975144f
+#define M_PI_4_F      0.785398163397448309615660845819875721f
+#define M_1_PI_F      0.318309886183790671537767526745028724f
+#define M_2_PI_F      0.636619772367581343075535053490057448f
+#define M_2_SQRTPI_F  1.12837916709551257389615890312154517f
+#define M_SQRT2_F     1.41421356237309504880168872420969808f
+#define M_SQRT1_2_F   0.707106781186547524400844362104849039f
+
+#define DBL_DIG 15
+#define DBL_MANT_DIG 53
+#define DBL_MAX_10_EXP +308
+#define DBL_MAX_EXP +1024
+#define DBL_MIN_10_EXP -307
+#define DBL_MIN_EXP -1021
+#define DBL_RADIX 2
+#define DBL_MAX 0x1.fffffffffffffp1023
+#define DBL_MIN 0x1.0p-1022
+#define DBL_EPSILON 0x1.0p-52
+
+#define M_E           0x1.5bf0a8b145769p+1
+#define M_LOG2E       0x1.71547652b82fep+0
+#define M_LOG10E      0x1.bcb7b1526e50ep-2
+#define M_LN2         0x1.62e42fefa39efp-1
+#define M_LN10        0x1.26bb1bbb55516p+1
+#define M_PI          0x1.921fb54442d18p+1
+#define M_PI_2        0x1.921fb54442d18p+0
+#define M_PI_4        0x1.921fb54442d18p-1
+#define M_1_PI        0x1.45f306dc9c883p-2
+#define M_2_PI        0x1.45f306dc9c883p-1
+#define M_2_SQRTPI    0x1.20dd750429b6dp+0
+#define M_SQRT2       0x1.6a09e667f3bcdp+0
+#define M_SQRT1_2     0x1.6a09e667f3bcdp-1
+
+#ifdef cl_khr_fp16
+
+#define HALF_DIG 3
+#define HALF_MANT_DIG 11
+#define HALF_MAX_10_EXP +4
+#define HALF_MAX_EXP +16
+#define HALF_MIN_10_EXP -4
+#define HALF_MIN_EXP -13
+#define HALF_RADIX 2
+#define HALF_MAX ((0x1.ffcp15h))
+#define HALF_MIN ((0x1.0p-14h))
+#define HALF_EPSILON ((0x1.0p-10h))
+
+#define M_E_H         2.71828182845904523536028747135266250h
+#define M_LOG2E_H     1.44269504088896340735992468100189214h
+#define M_LOG10E_H    0.434294481903251827651128918916605082h
+#define M_LN2_H       0.693147180559945309417232121458176568h
+#define M_LN10_H      2.30258509299404568401799145468436421h
+#define M_PI_H        3.14159265358979323846264338327950288h
+#define M_PI_2_H      1.57079632679489661923132169163975144h
+#define M_PI_4_H      0.785398163397448309615660845819875721h
+#define M_1_PI_H      0.318309886183790671537767526745028724h
+#define M_2_PI_H      0.636619772367581343075535053490057448h
+#define M_2_SQRTPI_H  1.12837916709551257389615890312154517h
+#define M_SQRT2_H     1.41421356237309504880168872420969808h
+#define M_SQRT1_2_H   0.707106781186547524400844362104849039h
+
+#endif //cl_khr_fp16
+
+#define CHAR_BIT  8
+#define SCHAR_MAX 127
+#define SCHAR_MIN (-128)
+#define UCHAR_MAX 255
+#define CHAR_MAX  SCHAR_MAX
+#define CHAR_MIN  SCHAR_MIN
+#define USHRT_MAX 65535
+#define SHRT_MAX  32767
+#define SHRT_MIN  (-32768)
+#define UINT_MAX  0xffffffff
+#define INT_MAX   2147483647
+#define INT_MIN   (-2147483647-1)
+#define ULONG_MAX 0xffffffffffffffffUL
+#define LONG_MAX  0x7fffffffffffffffL
+#define LONG_MIN  (-0x7fffffffffffffffL-1)
+
+// OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions
+
+// Flag type and values for barrier, mem_fence, read_mem_fence, write_mem_fence
+typedef uint cl_mem_fence_flags;
+
+/**
+ * Queue a memory fence to ensure correct
+ * ordering of memory operations to local memory
+ */
+#define CLK_LOCAL_MEM_FENCE    0x01
+
+/**
+ * Queue a memory fence to ensure correct
+ * ordering of memory operations to global memory
+ */
+#define CLK_GLOBAL_MEM_FENCE   0x02
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+typedef enum memory_scope {
+  memory_scope_work_item = __OPENCL_MEMORY_SCOPE_WORK_ITEM,
+  memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP,
+  memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE,
+#if defined(__opencl_c_atomic_scope_all_devices)
+  memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES,
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+  memory_scope_all_devices = memory_scope_all_svm_devices,
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif // defined(__opencl_c_atomic_scope_all_devices)
+/**
+ * Subgroups have different requirements on forward progress, so just test
+ * all the relevant macros.
+ * CL 3.0 sub-groups "they are not guaranteed to make independent forward progress"
+ * KHR subgroups "Subgroups within a workgroup are independent, make forward progress with respect to each other"
+ */
+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || defined(__opencl_c_subgroups)
+  memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP
+#endif
+} memory_scope;
+
+/**
+ * Queue a memory fence to ensure correct ordering of memory
+ * operations between work-items of a work-group to
+ * image memory.
+ */
+#define CLK_IMAGE_MEM_FENCE  0x04
+
+#ifndef ATOMIC_VAR_INIT
+#define ATOMIC_VAR_INIT(x) (x)
+#endif //ATOMIC_VAR_INIT
+#define ATOMIC_FLAG_INIT 0
+
+// enum values aligned with what clang uses in EmitAtomicExpr()
+typedef enum memory_order
+{
+  memory_order_relaxed = __ATOMIC_RELAXED,
+  memory_order_acquire = __ATOMIC_ACQUIRE,
+  memory_order_release = __ATOMIC_RELEASE,
+  memory_order_acq_rel = __ATOMIC_ACQ_REL,
+#if defined(__opencl_c_atomic_order_seq_cst)
+  memory_order_seq_cst = __ATOMIC_SEQ_CST
+#endif
+} memory_order;
+
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions
+
+// These values need to match the runtime equivalent
+//
+// Addressing Mode.
+//
+#define CLK_ADDRESS_NONE                0
+#define CLK_ADDRESS_CLAMP_TO_EDGE       2
+#define CLK_ADDRESS_CLAMP               4
+#define CLK_ADDRESS_REPEAT              6
+#define CLK_ADDRESS_MIRRORED_REPEAT     8
+
+//
+// Coordination Normalization
+//
+#define CLK_NORMALIZED_COORDS_FALSE     0
+#define CLK_NORMALIZED_COORDS_TRUE      1
+
+//
+// Filtering Mode.
+//
+#define CLK_FILTER_NEAREST              0x10
+#define CLK_FILTER_LINEAR               0x20
+
+#ifdef cl_khr_gl_msaa_sharing
+#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable
+#endif //cl_khr_gl_msaa_sharing
+
+//
+// Channel Datatype.
+//
+#define CLK_SNORM_INT8        0x10D0
+#define CLK_SNORM_INT16       0x10D1
+#define CLK_UNORM_INT8        0x10D2
+#define CLK_UNORM_INT16       0x10D3
+#define CLK_UNORM_SHORT_565   0x10D4
+#define CLK_UNORM_SHORT_555   0x10D5
+#define CLK_UNORM_INT_101010  0x10D6
+#define CLK_SIGNED_INT8       0x10D7
+#define CLK_SIGNED_INT16      0x10D8
+#define CLK_SIGNED_INT32      0x10D9
+#define CLK_UNSIGNED_INT8     0x10DA
+#define CLK_UNSIGNED_INT16    0x10DB
+#define CLK_UNSIGNED_INT32    0x10DC
+#define CLK_HALF_FLOAT        0x10DD
+#define CLK_FLOAT             0x10DE
+#define CLK_UNORM_INT24       0x10DF
+#if __OPENCL_C_VERSION__ >= CL_VERSION_3_0
+#define CLK_UNORM_INT_101010_2 0x10E0
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_3_0
+
+// Channel order, numbering must be aligned with cl_channel_order in cl.h
+//
+#define CLK_R         0x10B0
+#define CLK_A         0x10B1
+#define CLK_RG        0x10B2
+#define CLK_RA        0x10B3
+#define CLK_RGB       0x10B4
+#define CLK_RGBA      0x10B5
+#define CLK_BGRA      0x10B6
+#define CLK_ARGB      0x10B7
+#define CLK_INTENSITY 0x10B8
+#define CLK_LUMINANCE 0x10B9
+#define CLK_Rx                0x10BA
+#define CLK_RGx               0x10BB
+#define CLK_RGBx              0x10BC
+#define CLK_DEPTH             0x10BD
+#define CLK_DEPTH_STENCIL     0x10BE
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
+#define CLK_sRGB              0x10BF
+#define CLK_sRGBx             0x10C0
+#define CLK_sRGBA             0x10C1
+#define CLK_sBGRA             0x10C2
+#define CLK_ABGR              0x10C3
+#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
+
+// OpenCL v2.0 s6.13.16 - Pipe Functions
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#define CLK_NULL_RESERVE_ID (__builtin_astype(((void*)(__SIZE_MAX__)), reserve_id_t))
+
+// OpenCL v2.0 s6.13.17 - Enqueue Kernels
+#define CL_COMPLETE                                 0x0
+#define CL_RUNNING                                  0x1
+#define CL_SUBMITTED                                0x2
+#define CL_QUEUED                                   0x3
+
+#define CLK_SUCCESS                                 0
+#define CLK_ENQUEUE_FAILURE                         -101
+#define CLK_INVALID_QUEUE                           -102
+#define CLK_INVALID_NDRANGE                         -160
+#define CLK_INVALID_EVENT_WAIT_LIST                 -57
+#define CLK_DEVICE_QUEUE_FULL                       -161
+#define CLK_INVALID_ARG_SIZE                        -51
+#define CLK_EVENT_ALLOCATION_FAILURE                -100
+#define CLK_OUT_OF_RESOURCES                        -5
+
+#define CLK_NULL_QUEUE                              0
+#define CLK_NULL_EVENT (__builtin_astype(((__SIZE_MAX__)), clk_event_t))
+
+// execution model related definitions
+#define CLK_ENQUEUE_FLAGS_NO_WAIT                   0x0
+#define CLK_ENQUEUE_FLAGS_WAIT_KERNEL               0x1
+#define CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP           0x2
+
+typedef int kernel_enqueue_flags_t;
+typedef int clk_profiling_info;
+
+// Profiling info name (see capture_event_profiling_info)
+#define CLK_PROFILING_COMMAND_EXEC_TIME 0x1
+
+#define MAX_WORK_DIM 3
+
+#ifdef __opencl_c_device_enqueue
+typedef struct {
+  unsigned int workDimension;
+  size_t globalWorkOffset[MAX_WORK_DIM];
+  size_t globalWorkSize[MAX_WORK_DIM];
+  size_t localWorkSize[MAX_WORK_DIM];
+} ndrange_t;
+#endif // __opencl_c_device_enqueue
+
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+/**
+ * OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators
+ * Reinterprets a data type as another data type of the same size
+ */
+#define as_char(x) __builtin_astype((x), char)
+#define as_char2(x) __builtin_astype((x), char2)
+#define as_char3(x) __builtin_astype((x), char3)
+#define as_char4(x) __builtin_astype((x), char4)
+#define as_char8(x) __builtin_astype((x), char8)
+#define as_char16(x) __builtin_astype((x), char16)
+
+#define as_uchar(x) __builtin_astype((x), uchar)
+#define as_uchar2(x) __builtin_astype((x), uchar2)
+#define as_uchar3(x) __builtin_astype((x), uchar3)
+#define as_uchar4(x) __builtin_astype((x), uchar4)
+#define as_uchar8(x) __builtin_astype((x), uchar8)
+#define as_uchar16(x) __builtin_astype((x), uchar16)
+
+#define as_short(x) __builtin_astype((x), short)
+#define as_short2(x) __builtin_astype((x), short2)
+#define as_short3(x) __builtin_astype((x), short3)
+#define as_short4(x) __builtin_astype((x), short4)
+#define as_short8(x) __builtin_astype((x), short8)
+#define as_short16(x) __builtin_astype((x), short16)
+
+#define as_ushort(x) __builtin_astype((x), ushort)
+#define as_ushort2(x) __builtin_astype((x), ushort2)
+#define as_ushort3(x) __builtin_astype((x), ushort3)
+#define as_ushort4(x) __builtin_astype((x), ushort4)
+#define as_ushort8(x) __builtin_astype((x), ushort8)
+#define as_ushort16(x) __builtin_astype((x), ushort16)
+
+#define as_int(x) __builtin_astype((x), int)
+#define as_int2(x) __builtin_astype((x), int2)
+#define as_int3(x) __builtin_astype((x), int3)
+#define as_int4(x) __builtin_astype((x), int4)
+#define as_int8(x) __builtin_astype((x), int8)
+#define as_int16(x) __builtin_astype((x), int16)
+
+#define as_uint(x) __builtin_astype((x), uint)
+#define as_uint2(x) __builtin_astype((x), uint2)
+#define as_uint3(x) __builtin_astype((x), uint3)
+#define as_uint4(x) __builtin_astype((x), uint4)
+#define as_uint8(x) __builtin_astype((x), uint8)
+#define as_uint16(x) __builtin_astype((x), uint16)
+
+#define as_long(x) __builtin_astype((x), long)
+#define as_long2(x) __builtin_astype((x), long2)
+#define as_long3(x) __builtin_astype((x), long3)
+#define as_long4(x) __builtin_astype((x), long4)
+#define as_long8(x) __builtin_astype((x), long8)
+#define as_long16(x) __builtin_astype((x), long16)
+
+#define as_ulong(x) __builtin_astype((x), ulong)
+#define as_ulong2(x) __builtin_astype((x), ulong2)
+#define as_ulong3(x) __builtin_astype((x), ulong3)
+#define as_ulong4(x) __builtin_astype((x), ulong4)
+#define as_ulong8(x) __builtin_astype((x), ulong8)
+#define as_ulong16(x) __builtin_astype((x), ulong16)
+
+#define as_float(x) __builtin_astype((x), float)
+#define as_float2(x) __builtin_astype((x), float2)
+#define as_float3(x) __builtin_astype((x), float3)
+#define as_float4(x) __builtin_astype((x), float4)
+#define as_float8(x) __builtin_astype((x), float8)
+#define as_float16(x) __builtin_astype((x), float16)
+
+#ifdef cl_khr_fp64
+#define as_double(x) __builtin_astype((x), double)
+#define as_double2(x) __builtin_astype((x), double2)
+#define as_double3(x) __builtin_astype((x), double3)
+#define as_double4(x) __builtin_astype((x), double4)
+#define as_double8(x) __builtin_astype((x), double8)
+#define as_double16(x) __builtin_astype((x), double16)
+#endif // cl_khr_fp64
+
+#ifdef cl_khr_fp16
+#define as_half(x) __builtin_astype((x), half)
+#define as_half2(x) __builtin_astype((x), half2)
+#define as_half3(x) __builtin_astype((x), half3)
+#define as_half4(x) __builtin_astype((x), half4)
+#define as_half8(x) __builtin_astype((x), half8)
+#define as_half16(x) __builtin_astype((x), half16)
+#endif // cl_khr_fp16
+
+#define as_size_t(x) __builtin_astype((x), size_t)
+#define as_ptrdiff_t(x) __builtin_astype((x), ptrdiff_t)
+#define as_intptr_t(x) __builtin_astype((x), intptr_t)
+#define as_uintptr_t(x) __builtin_astype((x), uintptr_t)
+
+// C++ for OpenCL - __remove_address_space
+#if defined(__OPENCL_CPP_VERSION__)
+template <typename _Tp> struct __remove_address_space { using type = _Tp; };
+#if defined(__opencl_c_generic_address_space)
+template <typename _Tp> struct __remove_address_space<__generic _Tp> {
+  using type = _Tp;
+};
+#endif
+template <typename _Tp> struct __remove_address_space<__global _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__private _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__local _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__constant _Tp> {
+  using type = _Tp;
+};
+#endif
+
+// OpenCL v1.1 s6.9, v1.2/2.0 s6.10 - Function qualifiers
+
+#define __kernel_exec(X, typen) __kernel \
+	__attribute__((work_group_size_hint(X, 1, 1))) \
+	__attribute__((vec_type_hint(typen)))
+
+#define kernel_exec(X, typen) __kernel \
+	__attribute__((work_group_size_hint(X, 1, 1))) \
+	__attribute__((vec_type_hint(typen)))
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+// OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf
+
+int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)));
+#endif
+
+#ifdef cl_intel_device_side_avc_motion_estimation
+
+#define CLK_AVC_ME_MAJOR_16x16_INTEL 0x0
+#define CLK_AVC_ME_MAJOR_16x8_INTEL 0x1
+#define CLK_AVC_ME_MAJOR_8x16_INTEL 0x2
+#define CLK_AVC_ME_MAJOR_8x8_INTEL 0x3
+
+#define CLK_AVC_ME_MINOR_8x8_INTEL 0x0
+#define CLK_AVC_ME_MINOR_8x4_INTEL 0x1
+#define CLK_AVC_ME_MINOR_4x8_INTEL 0x2
+#define CLK_AVC_ME_MINOR_4x4_INTEL 0x3
+
+#define CLK_AVC_ME_MAJOR_FORWARD_INTEL 0x0
+#define CLK_AVC_ME_MAJOR_BACKWARD_INTEL 0x1
+#define CLK_AVC_ME_MAJOR_BIDIRECTIONAL_INTEL 0x2
+
+#define CLK_AVC_ME_PARTITION_MASK_ALL_INTEL 0x0
+#define CLK_AVC_ME_PARTITION_MASK_16x16_INTEL 0x7E
+#define CLK_AVC_ME_PARTITION_MASK_16x8_INTEL 0x7D
+#define CLK_AVC_ME_PARTITION_MASK_8x16_INTEL 0x7B
+#define CLK_AVC_ME_PARTITION_MASK_8x8_INTEL 0x77
+#define CLK_AVC_ME_PARTITION_MASK_8x4_INTEL 0x6F
+#define CLK_AVC_ME_PARTITION_MASK_4x8_INTEL 0x5F
+#define CLK_AVC_ME_PARTITION_MASK_4x4_INTEL 0x3F
+
+#define CLK_AVC_ME_SLICE_TYPE_PRED_INTEL 0x0
+#define CLK_AVC_ME_SLICE_TYPE_BPRED_INTEL 0x1
+#define CLK_AVC_ME_SLICE_TYPE_INTRA_INTEL 0x2
+
+#define CLK_AVC_ME_SEARCH_WINDOW_EXHAUSTIVE_INTEL 0x0
+#define CLK_AVC_ME_SEARCH_WINDOW_SMALL_INTEL 0x1
+#define CLK_AVC_ME_SEARCH_WINDOW_TINY_INTEL 0x2
+#define CLK_AVC_ME_SEARCH_WINDOW_EXTRA_TINY_INTEL 0x3
+#define CLK_AVC_ME_SEARCH_WINDOW_DIAMOND_INTEL 0x4
+#define CLK_AVC_ME_SEARCH_WINDOW_LARGE_DIAMOND_INTEL 0x5
+#define CLK_AVC_ME_SEARCH_WINDOW_RESERVED0_INTEL 0x6
+#define CLK_AVC_ME_SEARCH_WINDOW_RESERVED1_INTEL 0x7
+#define CLK_AVC_ME_SEARCH_WINDOW_CUSTOM_INTEL 0x8
+
+#define CLK_AVC_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0
+#define CLK_AVC_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x2
+
+#define CLK_AVC_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0
+#define CLK_AVC_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1
+#define CLK_AVC_ME_SUBPIXEL_MODE_QPEL_INTEL 0x3
+
+#define CLK_AVC_ME_COST_PRECISION_QPEL_INTEL 0x0
+#define CLK_AVC_ME_COST_PRECISION_HPEL_INTEL 0x1
+#define CLK_AVC_ME_COST_PRECISION_PEL_INTEL 0x2
+#define CLK_AVC_ME_COST_PRECISION_DPEL_INTEL 0x3
+
+#define CLK_AVC_ME_BIDIR_WEIGHT_QUARTER_INTEL 0x10
+#define CLK_AVC_ME_BIDIR_WEIGHT_THIRD_INTEL 0x15
+#define CLK_AVC_ME_BIDIR_WEIGHT_HALF_INTEL 0x20
+#define CLK_AVC_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 0x2B
+#define CLK_AVC_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 0x30
+
+#define CLK_AVC_ME_BORDER_REACHED_LEFT_INTEL 0x0
+#define CLK_AVC_ME_BORDER_REACHED_RIGHT_INTEL 0x2
+#define CLK_AVC_ME_BORDER_REACHED_TOP_INTEL 0x4
+#define CLK_AVC_ME_BORDER_REACHED_BOTTOM_INTEL 0x8
+
+#define CLK_AVC_ME_INTRA_16x16_INTEL 0x0
+#define CLK_AVC_ME_INTRA_8x8_INTEL 0x1
+#define CLK_AVC_ME_INTRA_4x4_INTEL 0x2
+
+#define CLK_AVC_ME_SKIP_BLOCK_PARTITION_16x16_INTEL 0x0
+#define CLK_AVC_ME_SKIP_BLOCK_PARTITION_8x8_INTEL 0x4000
+
+#define CLK_AVC_ME_SKIP_BLOCK_16x16_FORWARD_ENABLE_INTEL (0x1 << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_16x16_BACKWARD_ENABLE_INTEL (0x2 << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_16x16_DUAL_ENABLE_INTEL (0x3 << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_FORWARD_ENABLE_INTEL (0x55 << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_BACKWARD_ENABLE_INTEL (0xAA << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_DUAL_ENABLE_INTEL (0xFF << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_0_FORWARD_ENABLE_INTEL (0x1 << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_0_BACKWARD_ENABLE_INTEL (0x2 << 24)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_1_FORWARD_ENABLE_INTEL (0x1 << 26)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_1_BACKWARD_ENABLE_INTEL (0x2 << 26)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_2_FORWARD_ENABLE_INTEL (0x1 << 28)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_2_BACKWARD_ENABLE_INTEL (0x2 << 28)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_3_FORWARD_ENABLE_INTEL (0x1 << 30)
+#define CLK_AVC_ME_SKIP_BLOCK_8x8_3_BACKWARD_ENABLE_INTEL (0x2 << 30)
+
+#define CLK_AVC_ME_BLOCK_BASED_SKIP_4x4_INTEL 0x00
+#define CLK_AVC_ME_BLOCK_BASED_SKIP_8x8_INTEL 0x80
+
+#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_ALL_INTEL 0x0
+#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_16x16_INTEL 0x6
+#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_8x8_INTEL 0x5
+#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_4x4_INTEL 0x3
+
+#define CLK_AVC_ME_INTRA_NEIGHBOR_LEFT_MASK_ENABLE_INTEL 0x60
+#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_MASK_ENABLE_INTEL 0x10
+#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_RIGHT_MASK_ENABLE_INTEL 0x8
+#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_LEFT_MASK_ENABLE_INTEL 0x4
+
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7
+#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8
+#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0
+#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1
+#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2
+#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3
+
+#define CLK_AVC_ME_FRAME_FORWARD_INTEL 0x1
+#define CLK_AVC_ME_FRAME_BACKWARD_INTEL 0x2
+#define CLK_AVC_ME_FRAME_DUAL_INTEL 0x3
+
+#define CLK_AVC_ME_INTERLACED_SCAN_TOP_FIELD_INTEL 0x0
+#define CLK_AVC_ME_INTERLACED_SCAN_BOTTOM_FIELD_INTEL 0x1
+
+#define CLK_AVC_ME_INITIALIZE_INTEL 0x0
+
+#define CLK_AVC_IME_PAYLOAD_INITIALIZE_INTEL 0x0
+#define CLK_AVC_REF_PAYLOAD_INITIALIZE_INTEL 0x0
+#define CLK_AVC_SIC_PAYLOAD_INITIALIZE_INTEL 0x0
+
+#define CLK_AVC_IME_RESULT_INITIALIZE_INTEL 0x0
+#define CLK_AVC_REF_RESULT_INITIALIZE_INTEL 0x0
+#define CLK_AVC_SIC_RESULT_INITIALIZE_INTEL 0x0
+
+#define CLK_AVC_IME_RESULT_SINGLE_REFERENCE_STREAMOUT_INITIALIZE_INTEL 0x0
+#define CLK_AVC_IME_RESULT_SINGLE_REFERENCE_STREAMIN_INITIALIZE_INTEL 0x0
+#define CLK_AVC_IME_RESULT_DUAL_REFERENCE_STREAMOUT_INITIALIZE_INTEL 0x0
+#define CLK_AVC_IME_RESULT_DUAL_REFERENCE_STREAMIN_INITIALIZE_INTEL 0x0
+
+#endif // cl_intel_device_side_avc_motion_estimation
+
+// Disable any extensions we may have enabled previously.
+#pragma OPENCL EXTENSION all : disable
+
+#endif //_OPENCL_BASE_H_
diff --git a/drivers/pocl-gen7/share/pocl/include/opencl-c.h b/drivers/pocl-gen7/share/pocl/include/opencl-c.h
new file mode 100644
index 0000000..8479596
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/opencl-c.h
@@ -0,0 +1,18375 @@
+//===--- opencl-c.h - OpenCL C language builtin function header -----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _OPENCL_H_
+#define _OPENCL_H_
+
+#ifndef SKIP_HEADER_INCLUDE
+#include "opencl-c-base.h"
+#endif
+
+#if defined(__opencl_c_images)
+#ifndef cl_khr_depth_images
+#define cl_khr_depth_images
+#endif //cl_khr_depth_images
+#endif //defined(__opencl_c_images)
+
+#if __OPENCL_C_VERSION__ < CL_VERSION_2_0
+#ifdef cl_khr_3d_image_writes
+#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
+#endif //cl_khr_3d_image_writes
+#endif //__OPENCL_C_VERSION__ < CL_VERSION_2_0
+
+#if (defined(__OPENCL_CPP_VERSION__) ||                                        \
+     (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)) &&                              \
+    (defined(__SPIR__) || defined(__SPIRV__))
+#pragma OPENCL EXTENSION cl_intel_planar_yuv : begin
+#pragma OPENCL EXTENSION cl_intel_planar_yuv : end
+#endif // (defined(__OPENCL_CPP_VERSION__) ||
+       //  (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)) &&
+       // (defined(__SPIR__) || defined(__SPIRV__))
+
+#define __ovld __attribute__((overloadable))
+#define __conv __attribute__((convergent))
+
+// Optimizations
+#define __purefn __attribute__((pure))
+#define __cnfn __attribute__((const))
+
+
+// OpenCL v1.1/1.2/2.0 s6.2.3 - Explicit conversions
+
+char __ovld __cnfn convert_char_rte(char);
+char __ovld __cnfn convert_char_sat_rte(char);
+char __ovld __cnfn convert_char_rtz(char);
+char __ovld __cnfn convert_char_sat_rtz(char);
+char __ovld __cnfn convert_char_rtp(char);
+char __ovld __cnfn convert_char_sat_rtp(char);
+char __ovld __cnfn convert_char_rtn(char);
+char __ovld __cnfn convert_char_sat_rtn(char);
+char __ovld __cnfn convert_char(char);
+char __ovld __cnfn convert_char_sat(char);
+char __ovld __cnfn convert_char_rte(uchar);
+char __ovld __cnfn convert_char_sat_rte(uchar);
+char __ovld __cnfn convert_char_rtz(uchar);
+char __ovld __cnfn convert_char_sat_rtz(uchar);
+char __ovld __cnfn convert_char_rtp(uchar);
+char __ovld __cnfn convert_char_sat_rtp(uchar);
+char __ovld __cnfn convert_char_rtn(uchar);
+char __ovld __cnfn convert_char_sat_rtn(uchar);
+char __ovld __cnfn convert_char(uchar);
+char __ovld __cnfn convert_char_sat(uchar);
+char __ovld __cnfn convert_char_rte(short);
+char __ovld __cnfn convert_char_sat_rte(short);
+char __ovld __cnfn convert_char_rtz(short);
+char __ovld __cnfn convert_char_sat_rtz(short);
+char __ovld __cnfn convert_char_rtp(short);
+char __ovld __cnfn convert_char_sat_rtp(short);
+char __ovld __cnfn convert_char_rtn(short);
+char __ovld __cnfn convert_char_sat_rtn(short);
+char __ovld __cnfn convert_char(short);
+char __ovld __cnfn convert_char_sat(short);
+char __ovld __cnfn convert_char_rte(ushort);
+char __ovld __cnfn convert_char_sat_rte(ushort);
+char __ovld __cnfn convert_char_rtz(ushort);
+char __ovld __cnfn convert_char_sat_rtz(ushort);
+char __ovld __cnfn convert_char_rtp(ushort);
+char __ovld __cnfn convert_char_sat_rtp(ushort);
+char __ovld __cnfn convert_char_rtn(ushort);
+char __ovld __cnfn convert_char_sat_rtn(ushort);
+char __ovld __cnfn convert_char(ushort);
+char __ovld __cnfn convert_char_sat(ushort);
+char __ovld __cnfn convert_char_rte(int);
+char __ovld __cnfn convert_char_sat_rte(int);
+char __ovld __cnfn convert_char_rtz(int);
+char __ovld __cnfn convert_char_sat_rtz(int);
+char __ovld __cnfn convert_char_rtp(int);
+char __ovld __cnfn convert_char_sat_rtp(int);
+char __ovld __cnfn convert_char_rtn(int);
+char __ovld __cnfn convert_char_sat_rtn(int);
+char __ovld __cnfn convert_char(int);
+char __ovld __cnfn convert_char_sat(int);
+char __ovld __cnfn convert_char_rte(uint);
+char __ovld __cnfn convert_char_sat_rte(uint);
+char __ovld __cnfn convert_char_rtz(uint);
+char __ovld __cnfn convert_char_sat_rtz(uint);
+char __ovld __cnfn convert_char_rtp(uint);
+char __ovld __cnfn convert_char_sat_rtp(uint);
+char __ovld __cnfn convert_char_rtn(uint);
+char __ovld __cnfn convert_char_sat_rtn(uint);
+char __ovld __cnfn convert_char(uint);
+char __ovld __cnfn convert_char_sat(uint);
+char __ovld __cnfn convert_char_rte(long);
+char __ovld __cnfn convert_char_sat_rte(long);
+char __ovld __cnfn convert_char_rtz(long);
+char __ovld __cnfn convert_char_sat_rtz(long);
+char __ovld __cnfn convert_char_rtp(long);
+char __ovld __cnfn convert_char_sat_rtp(long);
+char __ovld __cnfn convert_char_rtn(long);
+char __ovld __cnfn convert_char_sat_rtn(long);
+char __ovld __cnfn convert_char(long);
+char __ovld __cnfn convert_char_sat(long);
+char __ovld __cnfn convert_char_rte(ulong);
+char __ovld __cnfn convert_char_sat_rte(ulong);
+char __ovld __cnfn convert_char_rtz(ulong);
+char __ovld __cnfn convert_char_sat_rtz(ulong);
+char __ovld __cnfn convert_char_rtp(ulong);
+char __ovld __cnfn convert_char_sat_rtp(ulong);
+char __ovld __cnfn convert_char_rtn(ulong);
+char __ovld __cnfn convert_char_sat_rtn(ulong);
+char __ovld __cnfn convert_char(ulong);
+char __ovld __cnfn convert_char_sat(ulong);
+char __ovld __cnfn convert_char_rte(float);
+char __ovld __cnfn convert_char_sat_rte(float);
+char __ovld __cnfn convert_char_rtz(float);
+char __ovld __cnfn convert_char_sat_rtz(float);
+char __ovld __cnfn convert_char_rtp(float);
+char __ovld __cnfn convert_char_sat_rtp(float);
+char __ovld __cnfn convert_char_rtn(float);
+char __ovld __cnfn convert_char_sat_rtn(float);
+char __ovld __cnfn convert_char(float);
+char __ovld __cnfn convert_char_sat(float);
+uchar __ovld __cnfn convert_uchar_rte(char);
+uchar __ovld __cnfn convert_uchar_sat_rte(char);
+uchar __ovld __cnfn convert_uchar_rtz(char);
+uchar __ovld __cnfn convert_uchar_sat_rtz(char);
+uchar __ovld __cnfn convert_uchar_rtp(char);
+uchar __ovld __cnfn convert_uchar_sat_rtp(char);
+uchar __ovld __cnfn convert_uchar_rtn(char);
+uchar __ovld __cnfn convert_uchar_sat_rtn(char);
+uchar __ovld __cnfn convert_uchar(char);
+uchar __ovld __cnfn convert_uchar_sat(char);
+uchar __ovld __cnfn convert_uchar_rte(uchar);
+uchar __ovld __cnfn convert_uchar_sat_rte(uchar);
+uchar __ovld __cnfn convert_uchar_rtz(uchar);
+uchar __ovld __cnfn convert_uchar_sat_rtz(uchar);
+uchar __ovld __cnfn convert_uchar_rtp(uchar);
+uchar __ovld __cnfn convert_uchar_sat_rtp(uchar);
+uchar __ovld __cnfn convert_uchar_rtn(uchar);
+uchar __ovld __cnfn convert_uchar_sat_rtn(uchar);
+uchar __ovld __cnfn convert_uchar(uchar);
+uchar __ovld __cnfn convert_uchar_sat(uchar);
+uchar __ovld __cnfn convert_uchar_rte(short);
+uchar __ovld __cnfn convert_uchar_sat_rte(short);
+uchar __ovld __cnfn convert_uchar_rtz(short);
+uchar __ovld __cnfn convert_uchar_sat_rtz(short);
+uchar __ovld __cnfn convert_uchar_rtp(short);
+uchar __ovld __cnfn convert_uchar_sat_rtp(short);
+uchar __ovld __cnfn convert_uchar_rtn(short);
+uchar __ovld __cnfn convert_uchar_sat_rtn(short);
+uchar __ovld __cnfn convert_uchar(short);
+uchar __ovld __cnfn convert_uchar_sat(short);
+uchar __ovld __cnfn convert_uchar_rte(ushort);
+uchar __ovld __cnfn convert_uchar_sat_rte(ushort);
+uchar __ovld __cnfn convert_uchar_rtz(ushort);
+uchar __ovld __cnfn convert_uchar_sat_rtz(ushort);
+uchar __ovld __cnfn convert_uchar_rtp(ushort);
+uchar __ovld __cnfn convert_uchar_sat_rtp(ushort);
+uchar __ovld __cnfn convert_uchar_rtn(ushort);
+uchar __ovld __cnfn convert_uchar_sat_rtn(ushort);
+uchar __ovld __cnfn convert_uchar(ushort);
+uchar __ovld __cnfn convert_uchar_sat(ushort);
+uchar __ovld __cnfn convert_uchar_rte(int);
+uchar __ovld __cnfn convert_uchar_sat_rte(int);
+uchar __ovld __cnfn convert_uchar_rtz(int);
+uchar __ovld __cnfn convert_uchar_sat_rtz(int);
+uchar __ovld __cnfn convert_uchar_rtp(int);
+uchar __ovld __cnfn convert_uchar_sat_rtp(int);
+uchar __ovld __cnfn convert_uchar_rtn(int);
+uchar __ovld __cnfn convert_uchar_sat_rtn(int);
+uchar __ovld __cnfn convert_uchar(int);
+uchar __ovld __cnfn convert_uchar_sat(int);
+uchar __ovld __cnfn convert_uchar_rte(uint);
+uchar __ovld __cnfn convert_uchar_sat_rte(uint);
+uchar __ovld __cnfn convert_uchar_rtz(uint);
+uchar __ovld __cnfn convert_uchar_sat_rtz(uint);
+uchar __ovld __cnfn convert_uchar_rtp(uint);
+uchar __ovld __cnfn convert_uchar_sat_rtp(uint);
+uchar __ovld __cnfn convert_uchar_rtn(uint);
+uchar __ovld __cnfn convert_uchar_sat_rtn(uint);
+uchar __ovld __cnfn convert_uchar(uint);
+uchar __ovld __cnfn convert_uchar_sat(uint);
+uchar __ovld __cnfn convert_uchar_rte(long);
+uchar __ovld __cnfn convert_uchar_sat_rte(long);
+uchar __ovld __cnfn convert_uchar_rtz(long);
+uchar __ovld __cnfn convert_uchar_sat_rtz(long);
+uchar __ovld __cnfn convert_uchar_rtp(long);
+uchar __ovld __cnfn convert_uchar_sat_rtp(long);
+uchar __ovld __cnfn convert_uchar_rtn(long);
+uchar __ovld __cnfn convert_uchar_sat_rtn(long);
+uchar __ovld __cnfn convert_uchar(long);
+uchar __ovld __cnfn convert_uchar_sat(long);
+uchar __ovld __cnfn convert_uchar_rte(ulong);
+uchar __ovld __cnfn convert_uchar_sat_rte(ulong);
+uchar __ovld __cnfn convert_uchar_rtz(ulong);
+uchar __ovld __cnfn convert_uchar_sat_rtz(ulong);
+uchar __ovld __cnfn convert_uchar_rtp(ulong);
+uchar __ovld __cnfn convert_uchar_sat_rtp(ulong);
+uchar __ovld __cnfn convert_uchar_rtn(ulong);
+uchar __ovld __cnfn convert_uchar_sat_rtn(ulong);
+uchar __ovld __cnfn convert_uchar(ulong);
+uchar __ovld __cnfn convert_uchar_sat(ulong);
+uchar __ovld __cnfn convert_uchar_rte(float);
+uchar __ovld __cnfn convert_uchar_sat_rte(float);
+uchar __ovld __cnfn convert_uchar_rtz(float);
+uchar __ovld __cnfn convert_uchar_sat_rtz(float);
+uchar __ovld __cnfn convert_uchar_rtp(float);
+uchar __ovld __cnfn convert_uchar_sat_rtp(float);
+uchar __ovld __cnfn convert_uchar_rtn(float);
+uchar __ovld __cnfn convert_uchar_sat_rtn(float);
+uchar __ovld __cnfn convert_uchar(float);
+uchar __ovld __cnfn convert_uchar_sat(float);
+
+short __ovld __cnfn convert_short_rte(char);
+short __ovld __cnfn convert_short_sat_rte(char);
+short __ovld __cnfn convert_short_rtz(char);
+short __ovld __cnfn convert_short_sat_rtz(char);
+short __ovld __cnfn convert_short_rtp(char);
+short __ovld __cnfn convert_short_sat_rtp(char);
+short __ovld __cnfn convert_short_rtn(char);
+short __ovld __cnfn convert_short_sat_rtn(char);
+short __ovld __cnfn convert_short(char);
+short __ovld __cnfn convert_short_sat(char);
+short __ovld __cnfn convert_short_rte(uchar);
+short __ovld __cnfn convert_short_sat_rte(uchar);
+short __ovld __cnfn convert_short_rtz(uchar);
+short __ovld __cnfn convert_short_sat_rtz(uchar);
+short __ovld __cnfn convert_short_rtp(uchar);
+short __ovld __cnfn convert_short_sat_rtp(uchar);
+short __ovld __cnfn convert_short_rtn(uchar);
+short __ovld __cnfn convert_short_sat_rtn(uchar);
+short __ovld __cnfn convert_short(uchar);
+short __ovld __cnfn convert_short_sat(uchar);
+short __ovld __cnfn convert_short_rte(short);
+short __ovld __cnfn convert_short_sat_rte(short);
+short __ovld __cnfn convert_short_rtz(short);
+short __ovld __cnfn convert_short_sat_rtz(short);
+short __ovld __cnfn convert_short_rtp(short);
+short __ovld __cnfn convert_short_sat_rtp(short);
+short __ovld __cnfn convert_short_rtn(short);
+short __ovld __cnfn convert_short_sat_rtn(short);
+short __ovld __cnfn convert_short(short);
+short __ovld __cnfn convert_short_sat(short);
+short __ovld __cnfn convert_short_rte(ushort);
+short __ovld __cnfn convert_short_sat_rte(ushort);
+short __ovld __cnfn convert_short_rtz(ushort);
+short __ovld __cnfn convert_short_sat_rtz(ushort);
+short __ovld __cnfn convert_short_rtp(ushort);
+short __ovld __cnfn convert_short_sat_rtp(ushort);
+short __ovld __cnfn convert_short_rtn(ushort);
+short __ovld __cnfn convert_short_sat_rtn(ushort);
+short __ovld __cnfn convert_short(ushort);
+short __ovld __cnfn convert_short_sat(ushort);
+short __ovld __cnfn convert_short_rte(int);
+short __ovld __cnfn convert_short_sat_rte(int);
+short __ovld __cnfn convert_short_rtz(int);
+short __ovld __cnfn convert_short_sat_rtz(int);
+short __ovld __cnfn convert_short_rtp(int);
+short __ovld __cnfn convert_short_sat_rtp(int);
+short __ovld __cnfn convert_short_rtn(int);
+short __ovld __cnfn convert_short_sat_rtn(int);
+short __ovld __cnfn convert_short(int);
+short __ovld __cnfn convert_short_sat(int);
+short __ovld __cnfn convert_short_rte(uint);
+short __ovld __cnfn convert_short_sat_rte(uint);
+short __ovld __cnfn convert_short_rtz(uint);
+short __ovld __cnfn convert_short_sat_rtz(uint);
+short __ovld __cnfn convert_short_rtp(uint);
+short __ovld __cnfn convert_short_sat_rtp(uint);
+short __ovld __cnfn convert_short_rtn(uint);
+short __ovld __cnfn convert_short_sat_rtn(uint);
+short __ovld __cnfn convert_short(uint);
+short __ovld __cnfn convert_short_sat(uint);
+short __ovld __cnfn convert_short_rte(long);
+short __ovld __cnfn convert_short_sat_rte(long);
+short __ovld __cnfn convert_short_rtz(long);
+short __ovld __cnfn convert_short_sat_rtz(long);
+short __ovld __cnfn convert_short_rtp(long);
+short __ovld __cnfn convert_short_sat_rtp(long);
+short __ovld __cnfn convert_short_rtn(long);
+short __ovld __cnfn convert_short_sat_rtn(long);
+short __ovld __cnfn convert_short(long);
+short __ovld __cnfn convert_short_sat(long);
+short __ovld __cnfn convert_short_rte(ulong);
+short __ovld __cnfn convert_short_sat_rte(ulong);
+short __ovld __cnfn convert_short_rtz(ulong);
+short __ovld __cnfn convert_short_sat_rtz(ulong);
+short __ovld __cnfn convert_short_rtp(ulong);
+short __ovld __cnfn convert_short_sat_rtp(ulong);
+short __ovld __cnfn convert_short_rtn(ulong);
+short __ovld __cnfn convert_short_sat_rtn(ulong);
+short __ovld __cnfn convert_short(ulong);
+short __ovld __cnfn convert_short_sat(ulong);
+short __ovld __cnfn convert_short_rte(float);
+short __ovld __cnfn convert_short_sat_rte(float);
+short __ovld __cnfn convert_short_rtz(float);
+short __ovld __cnfn convert_short_sat_rtz(float);
+short __ovld __cnfn convert_short_rtp(float);
+short __ovld __cnfn convert_short_sat_rtp(float);
+short __ovld __cnfn convert_short_rtn(float);
+short __ovld __cnfn convert_short_sat_rtn(float);
+short __ovld __cnfn convert_short(float);
+short __ovld __cnfn convert_short_sat(float);
+ushort __ovld __cnfn convert_ushort_rte(char);
+ushort __ovld __cnfn convert_ushort_sat_rte(char);
+ushort __ovld __cnfn convert_ushort_rtz(char);
+ushort __ovld __cnfn convert_ushort_sat_rtz(char);
+ushort __ovld __cnfn convert_ushort_rtp(char);
+ushort __ovld __cnfn convert_ushort_sat_rtp(char);
+ushort __ovld __cnfn convert_ushort_rtn(char);
+ushort __ovld __cnfn convert_ushort_sat_rtn(char);
+ushort __ovld __cnfn convert_ushort(char);
+ushort __ovld __cnfn convert_ushort_sat(char);
+ushort __ovld __cnfn convert_ushort_rte(uchar);
+ushort __ovld __cnfn convert_ushort_sat_rte(uchar);
+ushort __ovld __cnfn convert_ushort_rtz(uchar);
+ushort __ovld __cnfn convert_ushort_sat_rtz(uchar);
+ushort __ovld __cnfn convert_ushort_rtp(uchar);
+ushort __ovld __cnfn convert_ushort_sat_rtp(uchar);
+ushort __ovld __cnfn convert_ushort_rtn(uchar);
+ushort __ovld __cnfn convert_ushort_sat_rtn(uchar);
+ushort __ovld __cnfn convert_ushort(uchar);
+ushort __ovld __cnfn convert_ushort_sat(uchar);
+ushort __ovld __cnfn convert_ushort_rte(short);
+ushort __ovld __cnfn convert_ushort_sat_rte(short);
+ushort __ovld __cnfn convert_ushort_rtz(short);
+ushort __ovld __cnfn convert_ushort_sat_rtz(short);
+ushort __ovld __cnfn convert_ushort_rtp(short);
+ushort __ovld __cnfn convert_ushort_sat_rtp(short);
+ushort __ovld __cnfn convert_ushort_rtn(short);
+ushort __ovld __cnfn convert_ushort_sat_rtn(short);
+ushort __ovld __cnfn convert_ushort(short);
+ushort __ovld __cnfn convert_ushort_sat(short);
+ushort __ovld __cnfn convert_ushort_rte(ushort);
+ushort __ovld __cnfn convert_ushort_sat_rte(ushort);
+ushort __ovld __cnfn convert_ushort_rtz(ushort);
+ushort __ovld __cnfn convert_ushort_sat_rtz(ushort);
+ushort __ovld __cnfn convert_ushort_rtp(ushort);
+ushort __ovld __cnfn convert_ushort_sat_rtp(ushort);
+ushort __ovld __cnfn convert_ushort_rtn(ushort);
+ushort __ovld __cnfn convert_ushort_sat_rtn(ushort);
+ushort __ovld __cnfn convert_ushort(ushort);
+ushort __ovld __cnfn convert_ushort_sat(ushort);
+ushort __ovld __cnfn convert_ushort_rte(int);
+ushort __ovld __cnfn convert_ushort_sat_rte(int);
+ushort __ovld __cnfn convert_ushort_rtz(int);
+ushort __ovld __cnfn convert_ushort_sat_rtz(int);
+ushort __ovld __cnfn convert_ushort_rtp(int);
+ushort __ovld __cnfn convert_ushort_sat_rtp(int);
+ushort __ovld __cnfn convert_ushort_rtn(int);
+ushort __ovld __cnfn convert_ushort_sat_rtn(int);
+ushort __ovld __cnfn convert_ushort(int);
+ushort __ovld __cnfn convert_ushort_sat(int);
+ushort __ovld __cnfn convert_ushort_rte(uint);
+ushort __ovld __cnfn convert_ushort_sat_rte(uint);
+ushort __ovld __cnfn convert_ushort_rtz(uint);
+ushort __ovld __cnfn convert_ushort_sat_rtz(uint);
+ushort __ovld __cnfn convert_ushort_rtp(uint);
+ushort __ovld __cnfn convert_ushort_sat_rtp(uint);
+ushort __ovld __cnfn convert_ushort_rtn(uint);
+ushort __ovld __cnfn convert_ushort_sat_rtn(uint);
+ushort __ovld __cnfn convert_ushort(uint);
+ushort __ovld __cnfn convert_ushort_sat(uint);
+ushort __ovld __cnfn convert_ushort_rte(long);
+ushort __ovld __cnfn convert_ushort_sat_rte(long);
+ushort __ovld __cnfn convert_ushort_rtz(long);
+ushort __ovld __cnfn convert_ushort_sat_rtz(long);
+ushort __ovld __cnfn convert_ushort_rtp(long);
+ushort __ovld __cnfn convert_ushort_sat_rtp(long);
+ushort __ovld __cnfn convert_ushort_rtn(long);
+ushort __ovld __cnfn convert_ushort_sat_rtn(long);
+ushort __ovld __cnfn convert_ushort(long);
+ushort __ovld __cnfn convert_ushort_sat(long);
+ushort __ovld __cnfn convert_ushort_rte(ulong);
+ushort __ovld __cnfn convert_ushort_sat_rte(ulong);
+ushort __ovld __cnfn convert_ushort_rtz(ulong);
+ushort __ovld __cnfn convert_ushort_sat_rtz(ulong);
+ushort __ovld __cnfn convert_ushort_rtp(ulong);
+ushort __ovld __cnfn convert_ushort_sat_rtp(ulong);
+ushort __ovld __cnfn convert_ushort_rtn(ulong);
+ushort __ovld __cnfn convert_ushort_sat_rtn(ulong);
+ushort __ovld __cnfn convert_ushort(ulong);
+ushort __ovld __cnfn convert_ushort_sat(ulong);
+ushort __ovld __cnfn convert_ushort_rte(float);
+ushort __ovld __cnfn convert_ushort_sat_rte(float);
+ushort __ovld __cnfn convert_ushort_rtz(float);
+ushort __ovld __cnfn convert_ushort_sat_rtz(float);
+ushort __ovld __cnfn convert_ushort_rtp(float);
+ushort __ovld __cnfn convert_ushort_sat_rtp(float);
+ushort __ovld __cnfn convert_ushort_rtn(float);
+ushort __ovld __cnfn convert_ushort_sat_rtn(float);
+ushort __ovld __cnfn convert_ushort(float);
+ushort __ovld __cnfn convert_ushort_sat(float);
+int __ovld __cnfn convert_int_rte(char);
+int __ovld __cnfn convert_int_sat_rte(char);
+int __ovld __cnfn convert_int_rtz(char);
+int __ovld __cnfn convert_int_sat_rtz(char);
+int __ovld __cnfn convert_int_rtp(char);
+int __ovld __cnfn convert_int_sat_rtp(char);
+int __ovld __cnfn convert_int_rtn(char);
+int __ovld __cnfn convert_int_sat_rtn(char);
+int __ovld __cnfn convert_int(char);
+int __ovld __cnfn convert_int_sat(char);
+int __ovld __cnfn convert_int_rte(uchar);
+int __ovld __cnfn convert_int_sat_rte(uchar);
+int __ovld __cnfn convert_int_rtz(uchar);
+int __ovld __cnfn convert_int_sat_rtz(uchar);
+int __ovld __cnfn convert_int_rtp(uchar);
+int __ovld __cnfn convert_int_sat_rtp(uchar);
+int __ovld __cnfn convert_int_rtn(uchar);
+int __ovld __cnfn convert_int_sat_rtn(uchar);
+int __ovld __cnfn convert_int(uchar);
+int __ovld __cnfn convert_int_sat(uchar);
+int __ovld __cnfn convert_int_rte(short);
+int __ovld __cnfn convert_int_sat_rte(short);
+int __ovld __cnfn convert_int_rtz(short);
+int __ovld __cnfn convert_int_sat_rtz(short);
+int __ovld __cnfn convert_int_rtp(short);
+int __ovld __cnfn convert_int_sat_rtp(short);
+int __ovld __cnfn convert_int_rtn(short);
+int __ovld __cnfn convert_int_sat_rtn(short);
+int __ovld __cnfn convert_int(short);
+int __ovld __cnfn convert_int_sat(short);
+int __ovld __cnfn convert_int_rte(ushort);
+int __ovld __cnfn convert_int_sat_rte(ushort);
+int __ovld __cnfn convert_int_rtz(ushort);
+int __ovld __cnfn convert_int_sat_rtz(ushort);
+int __ovld __cnfn convert_int_rtp(ushort);
+int __ovld __cnfn convert_int_sat_rtp(ushort);
+int __ovld __cnfn convert_int_rtn(ushort);
+int __ovld __cnfn convert_int_sat_rtn(ushort);
+int __ovld __cnfn convert_int(ushort);
+int __ovld __cnfn convert_int_sat(ushort);
+int __ovld __cnfn convert_int_rte(int);
+int __ovld __cnfn convert_int_sat_rte(int);
+int __ovld __cnfn convert_int_rtz(int);
+int __ovld __cnfn convert_int_sat_rtz(int);
+int __ovld __cnfn convert_int_rtp(int);
+int __ovld __cnfn convert_int_sat_rtp(int);
+int __ovld __cnfn convert_int_rtn(int);
+int __ovld __cnfn convert_int_sat_rtn(int);
+int __ovld __cnfn convert_int(int);
+int __ovld __cnfn convert_int_sat(int);
+int __ovld __cnfn convert_int_rte(uint);
+int __ovld __cnfn convert_int_sat_rte(uint);
+int __ovld __cnfn convert_int_rtz(uint);
+int __ovld __cnfn convert_int_sat_rtz(uint);
+int __ovld __cnfn convert_int_rtp(uint);
+int __ovld __cnfn convert_int_sat_rtp(uint);
+int __ovld __cnfn convert_int_rtn(uint);
+int __ovld __cnfn convert_int_sat_rtn(uint);
+int __ovld __cnfn convert_int(uint);
+int __ovld __cnfn convert_int_sat(uint);
+int __ovld __cnfn convert_int_rte(long);
+int __ovld __cnfn convert_int_sat_rte(long);
+int __ovld __cnfn convert_int_rtz(long);
+int __ovld __cnfn convert_int_sat_rtz(long);
+int __ovld __cnfn convert_int_rtp(long);
+int __ovld __cnfn convert_int_sat_rtp(long);
+int __ovld __cnfn convert_int_rtn(long);
+int __ovld __cnfn convert_int_sat_rtn(long);
+int __ovld __cnfn convert_int(long);
+int __ovld __cnfn convert_int_sat(long);
+int __ovld __cnfn convert_int_rte(ulong);
+int __ovld __cnfn convert_int_sat_rte(ulong);
+int __ovld __cnfn convert_int_rtz(ulong);
+int __ovld __cnfn convert_int_sat_rtz(ulong);
+int __ovld __cnfn convert_int_rtp(ulong);
+int __ovld __cnfn convert_int_sat_rtp(ulong);
+int __ovld __cnfn convert_int_rtn(ulong);
+int __ovld __cnfn convert_int_sat_rtn(ulong);
+int __ovld __cnfn convert_int(ulong);
+int __ovld __cnfn convert_int_sat(ulong);
+int __ovld __cnfn convert_int_rte(float);
+int __ovld __cnfn convert_int_sat_rte(float);
+int __ovld __cnfn convert_int_rtz(float);
+int __ovld __cnfn convert_int_sat_rtz(float);
+int __ovld __cnfn convert_int_rtp(float);
+int __ovld __cnfn convert_int_sat_rtp(float);
+int __ovld __cnfn convert_int_rtn(float);
+int __ovld __cnfn convert_int_sat_rtn(float);
+int __ovld __cnfn convert_int(float);
+int __ovld __cnfn convert_int_sat(float);
+uint __ovld __cnfn convert_uint_rte(char);
+uint __ovld __cnfn convert_uint_sat_rte(char);
+uint __ovld __cnfn convert_uint_rtz(char);
+uint __ovld __cnfn convert_uint_sat_rtz(char);
+uint __ovld __cnfn convert_uint_rtp(char);
+uint __ovld __cnfn convert_uint_sat_rtp(char);
+uint __ovld __cnfn convert_uint_rtn(char);
+uint __ovld __cnfn convert_uint_sat_rtn(char);
+uint __ovld __cnfn convert_uint(char);
+uint __ovld __cnfn convert_uint_sat(char);
+uint __ovld __cnfn convert_uint_rte(uchar);
+uint __ovld __cnfn convert_uint_sat_rte(uchar);
+uint __ovld __cnfn convert_uint_rtz(uchar);
+uint __ovld __cnfn convert_uint_sat_rtz(uchar);
+uint __ovld __cnfn convert_uint_rtp(uchar);
+uint __ovld __cnfn convert_uint_sat_rtp(uchar);
+uint __ovld __cnfn convert_uint_rtn(uchar);
+uint __ovld __cnfn convert_uint_sat_rtn(uchar);
+uint __ovld __cnfn convert_uint(uchar);
+uint __ovld __cnfn convert_uint_sat(uchar);
+uint __ovld __cnfn convert_uint_rte(short);
+uint __ovld __cnfn convert_uint_sat_rte(short);
+uint __ovld __cnfn convert_uint_rtz(short);
+uint __ovld __cnfn convert_uint_sat_rtz(short);
+uint __ovld __cnfn convert_uint_rtp(short);
+uint __ovld __cnfn convert_uint_sat_rtp(short);
+uint __ovld __cnfn convert_uint_rtn(short);
+uint __ovld __cnfn convert_uint_sat_rtn(short);
+uint __ovld __cnfn convert_uint(short);
+uint __ovld __cnfn convert_uint_sat(short);
+uint __ovld __cnfn convert_uint_rte(ushort);
+uint __ovld __cnfn convert_uint_sat_rte(ushort);
+uint __ovld __cnfn convert_uint_rtz(ushort);
+uint __ovld __cnfn convert_uint_sat_rtz(ushort);
+uint __ovld __cnfn convert_uint_rtp(ushort);
+uint __ovld __cnfn convert_uint_sat_rtp(ushort);
+uint __ovld __cnfn convert_uint_rtn(ushort);
+uint __ovld __cnfn convert_uint_sat_rtn(ushort);
+uint __ovld __cnfn convert_uint(ushort);
+uint __ovld __cnfn convert_uint_sat(ushort);
+uint __ovld __cnfn convert_uint_rte(int);
+uint __ovld __cnfn convert_uint_sat_rte(int);
+uint __ovld __cnfn convert_uint_rtz(int);
+uint __ovld __cnfn convert_uint_sat_rtz(int);
+uint __ovld __cnfn convert_uint_rtp(int);
+uint __ovld __cnfn convert_uint_sat_rtp(int);
+uint __ovld __cnfn convert_uint_rtn(int);
+uint __ovld __cnfn convert_uint_sat_rtn(int);
+uint __ovld __cnfn convert_uint(int);
+uint __ovld __cnfn convert_uint_sat(int);
+uint __ovld __cnfn convert_uint_rte(uint);
+uint __ovld __cnfn convert_uint_sat_rte(uint);
+uint __ovld __cnfn convert_uint_rtz(uint);
+uint __ovld __cnfn convert_uint_sat_rtz(uint);
+uint __ovld __cnfn convert_uint_rtp(uint);
+uint __ovld __cnfn convert_uint_sat_rtp(uint);
+uint __ovld __cnfn convert_uint_rtn(uint);
+uint __ovld __cnfn convert_uint_sat_rtn(uint);
+uint __ovld __cnfn convert_uint(uint);
+uint __ovld __cnfn convert_uint_sat(uint);
+uint __ovld __cnfn convert_uint_rte(long);
+uint __ovld __cnfn convert_uint_sat_rte(long);
+uint __ovld __cnfn convert_uint_rtz(long);
+uint __ovld __cnfn convert_uint_sat_rtz(long);
+uint __ovld __cnfn convert_uint_rtp(long);
+uint __ovld __cnfn convert_uint_sat_rtp(long);
+uint __ovld __cnfn convert_uint_rtn(long);
+uint __ovld __cnfn convert_uint_sat_rtn(long);
+uint __ovld __cnfn convert_uint(long);
+uint __ovld __cnfn convert_uint_sat(long);
+uint __ovld __cnfn convert_uint_rte(ulong);
+uint __ovld __cnfn convert_uint_sat_rte(ulong);
+uint __ovld __cnfn convert_uint_rtz(ulong);
+uint __ovld __cnfn convert_uint_sat_rtz(ulong);
+uint __ovld __cnfn convert_uint_rtp(ulong);
+uint __ovld __cnfn convert_uint_sat_rtp(ulong);
+uint __ovld __cnfn convert_uint_rtn(ulong);
+uint __ovld __cnfn convert_uint_sat_rtn(ulong);
+uint __ovld __cnfn convert_uint(ulong);
+uint __ovld __cnfn convert_uint_sat(ulong);
+uint __ovld __cnfn convert_uint_rte(float);
+uint __ovld __cnfn convert_uint_sat_rte(float);
+uint __ovld __cnfn convert_uint_rtz(float);
+uint __ovld __cnfn convert_uint_sat_rtz(float);
+uint __ovld __cnfn convert_uint_rtp(float);
+uint __ovld __cnfn convert_uint_sat_rtp(float);
+uint __ovld __cnfn convert_uint_rtn(float);
+uint __ovld __cnfn convert_uint_sat_rtn(float);
+uint __ovld __cnfn convert_uint(float);
+uint __ovld __cnfn convert_uint_sat(float);
+long __ovld __cnfn convert_long_rte(char);
+long __ovld __cnfn convert_long_sat_rte(char);
+long __ovld __cnfn convert_long_rtz(char);
+long __ovld __cnfn convert_long_sat_rtz(char);
+long __ovld __cnfn convert_long_rtp(char);
+long __ovld __cnfn convert_long_sat_rtp(char);
+long __ovld __cnfn convert_long_rtn(char);
+long __ovld __cnfn convert_long_sat_rtn(char);
+long __ovld __cnfn convert_long(char);
+long __ovld __cnfn convert_long_sat(char);
+long __ovld __cnfn convert_long_rte(uchar);
+long __ovld __cnfn convert_long_sat_rte(uchar);
+long __ovld __cnfn convert_long_rtz(uchar);
+long __ovld __cnfn convert_long_sat_rtz(uchar);
+long __ovld __cnfn convert_long_rtp(uchar);
+long __ovld __cnfn convert_long_sat_rtp(uchar);
+long __ovld __cnfn convert_long_rtn(uchar);
+long __ovld __cnfn convert_long_sat_rtn(uchar);
+long __ovld __cnfn convert_long(uchar);
+long __ovld __cnfn convert_long_sat(uchar);
+long __ovld __cnfn convert_long_rte(short);
+long __ovld __cnfn convert_long_sat_rte(short);
+long __ovld __cnfn convert_long_rtz(short);
+long __ovld __cnfn convert_long_sat_rtz(short);
+long __ovld __cnfn convert_long_rtp(short);
+long __ovld __cnfn convert_long_sat_rtp(short);
+long __ovld __cnfn convert_long_rtn(short);
+long __ovld __cnfn convert_long_sat_rtn(short);
+long __ovld __cnfn convert_long(short);
+long __ovld __cnfn convert_long_sat(short);
+long __ovld __cnfn convert_long_rte(ushort);
+long __ovld __cnfn convert_long_sat_rte(ushort);
+long __ovld __cnfn convert_long_rtz(ushort);
+long __ovld __cnfn convert_long_sat_rtz(ushort);
+long __ovld __cnfn convert_long_rtp(ushort);
+long __ovld __cnfn convert_long_sat_rtp(ushort);
+long __ovld __cnfn convert_long_rtn(ushort);
+long __ovld __cnfn convert_long_sat_rtn(ushort);
+long __ovld __cnfn convert_long(ushort);
+long __ovld __cnfn convert_long_sat(ushort);
+long __ovld __cnfn convert_long_rte(int);
+long __ovld __cnfn convert_long_sat_rte(int);
+long __ovld __cnfn convert_long_rtz(int);
+long __ovld __cnfn convert_long_sat_rtz(int);
+long __ovld __cnfn convert_long_rtp(int);
+long __ovld __cnfn convert_long_sat_rtp(int);
+long __ovld __cnfn convert_long_rtn(int);
+long __ovld __cnfn convert_long_sat_rtn(int);
+long __ovld __cnfn convert_long(int);
+long __ovld __cnfn convert_long_sat(int);
+long __ovld __cnfn convert_long_rte(uint);
+long __ovld __cnfn convert_long_sat_rte(uint);
+long __ovld __cnfn convert_long_rtz(uint);
+long __ovld __cnfn convert_long_sat_rtz(uint);
+long __ovld __cnfn convert_long_rtp(uint);
+long __ovld __cnfn convert_long_sat_rtp(uint);
+long __ovld __cnfn convert_long_rtn(uint);
+long __ovld __cnfn convert_long_sat_rtn(uint);
+long __ovld __cnfn convert_long(uint);
+long __ovld __cnfn convert_long_sat(uint);
+long __ovld __cnfn convert_long_rte(long);
+long __ovld __cnfn convert_long_sat_rte(long);
+long __ovld __cnfn convert_long_rtz(long);
+long __ovld __cnfn convert_long_sat_rtz(long);
+long __ovld __cnfn convert_long_rtp(long);
+long __ovld __cnfn convert_long_sat_rtp(long);
+long __ovld __cnfn convert_long_rtn(long);
+long __ovld __cnfn convert_long_sat_rtn(long);
+long __ovld __cnfn convert_long(long);
+long __ovld __cnfn convert_long_sat(long);
+long __ovld __cnfn convert_long_rte(ulong);
+long __ovld __cnfn convert_long_sat_rte(ulong);
+long __ovld __cnfn convert_long_rtz(ulong);
+long __ovld __cnfn convert_long_sat_rtz(ulong);
+long __ovld __cnfn convert_long_rtp(ulong);
+long __ovld __cnfn convert_long_sat_rtp(ulong);
+long __ovld __cnfn convert_long_rtn(ulong);
+long __ovld __cnfn convert_long_sat_rtn(ulong);
+long __ovld __cnfn convert_long(ulong);
+long __ovld __cnfn convert_long_sat(ulong);
+long __ovld __cnfn convert_long_rte(float);
+long __ovld __cnfn convert_long_sat_rte(float);
+long __ovld __cnfn convert_long_rtz(float);
+long __ovld __cnfn convert_long_sat_rtz(float);
+long __ovld __cnfn convert_long_rtp(float);
+long __ovld __cnfn convert_long_sat_rtp(float);
+long __ovld __cnfn convert_long_rtn(float);
+long __ovld __cnfn convert_long_sat_rtn(float);
+long __ovld __cnfn convert_long(float);
+long __ovld __cnfn convert_long_sat(float);
+ulong __ovld __cnfn convert_ulong_rte(char);
+ulong __ovld __cnfn convert_ulong_sat_rte(char);
+ulong __ovld __cnfn convert_ulong_rtz(char);
+ulong __ovld __cnfn convert_ulong_sat_rtz(char);
+ulong __ovld __cnfn convert_ulong_rtp(char);
+ulong __ovld __cnfn convert_ulong_sat_rtp(char);
+ulong __ovld __cnfn convert_ulong_rtn(char);
+ulong __ovld __cnfn convert_ulong_sat_rtn(char);
+ulong __ovld __cnfn convert_ulong(char);
+ulong __ovld __cnfn convert_ulong_sat(char);
+ulong __ovld __cnfn convert_ulong_rte(uchar);
+ulong __ovld __cnfn convert_ulong_sat_rte(uchar);
+ulong __ovld __cnfn convert_ulong_rtz(uchar);
+ulong __ovld __cnfn convert_ulong_sat_rtz(uchar);
+ulong __ovld __cnfn convert_ulong_rtp(uchar);
+ulong __ovld __cnfn convert_ulong_sat_rtp(uchar);
+ulong __ovld __cnfn convert_ulong_rtn(uchar);
+ulong __ovld __cnfn convert_ulong_sat_rtn(uchar);
+ulong __ovld __cnfn convert_ulong(uchar);
+ulong __ovld __cnfn convert_ulong_sat(uchar);
+ulong __ovld __cnfn convert_ulong_rte(short);
+ulong __ovld __cnfn convert_ulong_sat_rte(short);
+ulong __ovld __cnfn convert_ulong_rtz(short);
+ulong __ovld __cnfn convert_ulong_sat_rtz(short);
+ulong __ovld __cnfn convert_ulong_rtp(short);
+ulong __ovld __cnfn convert_ulong_sat_rtp(short);
+ulong __ovld __cnfn convert_ulong_rtn(short);
+ulong __ovld __cnfn convert_ulong_sat_rtn(short);
+ulong __ovld __cnfn convert_ulong(short);
+ulong __ovld __cnfn convert_ulong_sat(short);
+ulong __ovld __cnfn convert_ulong_rte(ushort);
+ulong __ovld __cnfn convert_ulong_sat_rte(ushort);
+ulong __ovld __cnfn convert_ulong_rtz(ushort);
+ulong __ovld __cnfn convert_ulong_sat_rtz(ushort);
+ulong __ovld __cnfn convert_ulong_rtp(ushort);
+ulong __ovld __cnfn convert_ulong_sat_rtp(ushort);
+ulong __ovld __cnfn convert_ulong_rtn(ushort);
+ulong __ovld __cnfn convert_ulong_sat_rtn(ushort);
+ulong __ovld __cnfn convert_ulong(ushort);
+ulong __ovld __cnfn convert_ulong_sat(ushort);
+ulong __ovld __cnfn convert_ulong_rte(int);
+ulong __ovld __cnfn convert_ulong_sat_rte(int);
+ulong __ovld __cnfn convert_ulong_rtz(int);
+ulong __ovld __cnfn convert_ulong_sat_rtz(int);
+ulong __ovld __cnfn convert_ulong_rtp(int);
+ulong __ovld __cnfn convert_ulong_sat_rtp(int);
+ulong __ovld __cnfn convert_ulong_rtn(int);
+ulong __ovld __cnfn convert_ulong_sat_rtn(int);
+ulong __ovld __cnfn convert_ulong(int);
+ulong __ovld __cnfn convert_ulong_sat(int);
+ulong __ovld __cnfn convert_ulong_rte(uint);
+ulong __ovld __cnfn convert_ulong_sat_rte(uint);
+ulong __ovld __cnfn convert_ulong_rtz(uint);
+ulong __ovld __cnfn convert_ulong_sat_rtz(uint);
+ulong __ovld __cnfn convert_ulong_rtp(uint);
+ulong __ovld __cnfn convert_ulong_sat_rtp(uint);
+ulong __ovld __cnfn convert_ulong_rtn(uint);
+ulong __ovld __cnfn convert_ulong_sat_rtn(uint);
+ulong __ovld __cnfn convert_ulong(uint);
+ulong __ovld __cnfn convert_ulong_sat(uint);
+ulong __ovld __cnfn convert_ulong_rte(long);
+ulong __ovld __cnfn convert_ulong_sat_rte(long);
+ulong __ovld __cnfn convert_ulong_rtz(long);
+ulong __ovld __cnfn convert_ulong_sat_rtz(long);
+ulong __ovld __cnfn convert_ulong_rtp(long);
+ulong __ovld __cnfn convert_ulong_sat_rtp(long);
+ulong __ovld __cnfn convert_ulong_rtn(long);
+ulong __ovld __cnfn convert_ulong_sat_rtn(long);
+ulong __ovld __cnfn convert_ulong(long);
+ulong __ovld __cnfn convert_ulong_sat(long);
+ulong __ovld __cnfn convert_ulong_rte(ulong);
+ulong __ovld __cnfn convert_ulong_sat_rte(ulong);
+ulong __ovld __cnfn convert_ulong_rtz(ulong);
+ulong __ovld __cnfn convert_ulong_sat_rtz(ulong);
+ulong __ovld __cnfn convert_ulong_rtp(ulong);
+ulong __ovld __cnfn convert_ulong_sat_rtp(ulong);
+ulong __ovld __cnfn convert_ulong_rtn(ulong);
+ulong __ovld __cnfn convert_ulong_sat_rtn(ulong);
+ulong __ovld __cnfn convert_ulong(ulong);
+ulong __ovld __cnfn convert_ulong_sat(ulong);
+ulong __ovld __cnfn convert_ulong_rte(float);
+ulong __ovld __cnfn convert_ulong_sat_rte(float);
+ulong __ovld __cnfn convert_ulong_rtz(float);
+ulong __ovld __cnfn convert_ulong_sat_rtz(float);
+ulong __ovld __cnfn convert_ulong_rtp(float);
+ulong __ovld __cnfn convert_ulong_sat_rtp(float);
+ulong __ovld __cnfn convert_ulong_rtn(float);
+ulong __ovld __cnfn convert_ulong_sat_rtn(float);
+ulong __ovld __cnfn convert_ulong(float);
+ulong __ovld __cnfn convert_ulong_sat(float);
+float __ovld __cnfn convert_float_rte(char);
+float __ovld __cnfn convert_float_rtz(char);
+float __ovld __cnfn convert_float_rtp(char);
+float __ovld __cnfn convert_float_rtn(char);
+float __ovld __cnfn convert_float(char);
+float __ovld __cnfn convert_float_rte(uchar);
+float __ovld __cnfn convert_float_rtz(uchar);
+float __ovld __cnfn convert_float_rtp(uchar);
+float __ovld __cnfn convert_float_rtn(uchar);
+float __ovld __cnfn convert_float(uchar);
+float __ovld __cnfn convert_float_rte(short);
+float __ovld __cnfn convert_float_rtz(short);
+float __ovld __cnfn convert_float_rtp(short);
+float __ovld __cnfn convert_float_rtn(short);
+float __ovld __cnfn convert_float(short);
+float __ovld __cnfn convert_float_rte(ushort);
+float __ovld __cnfn convert_float_rtz(ushort);
+float __ovld __cnfn convert_float_rtp(ushort);
+float __ovld __cnfn convert_float_rtn(ushort);
+float __ovld __cnfn convert_float(ushort);
+float __ovld __cnfn convert_float_rte(int);
+float __ovld __cnfn convert_float_rtz(int);
+float __ovld __cnfn convert_float_rtp(int);
+float __ovld __cnfn convert_float_rtn(int);
+float __ovld __cnfn convert_float(int);
+float __ovld __cnfn convert_float_rte(uint);
+float __ovld __cnfn convert_float_rtz(uint);
+float __ovld __cnfn convert_float_rtp(uint);
+float __ovld __cnfn convert_float_rtn(uint);
+float __ovld __cnfn convert_float(uint);
+float __ovld __cnfn convert_float_rte(long);
+float __ovld __cnfn convert_float_rtz(long);
+float __ovld __cnfn convert_float_rtp(long);
+float __ovld __cnfn convert_float_rtn(long);
+float __ovld __cnfn convert_float(long);
+float __ovld __cnfn convert_float_rte(ulong);
+float __ovld __cnfn convert_float_rtz(ulong);
+float __ovld __cnfn convert_float_rtp(ulong);
+float __ovld __cnfn convert_float_rtn(ulong);
+float __ovld __cnfn convert_float(ulong);
+float __ovld __cnfn convert_float_rte(float);
+float __ovld __cnfn convert_float_rtz(float);
+float __ovld __cnfn convert_float_rtp(float);
+float __ovld __cnfn convert_float_rtn(float);
+float __ovld __cnfn convert_float(float);
+char2 __ovld __cnfn convert_char2_rte(char2);
+char2 __ovld __cnfn convert_char2_sat_rte(char2);
+char2 __ovld __cnfn convert_char2_rtz(char2);
+char2 __ovld __cnfn convert_char2_sat_rtz(char2);
+char2 __ovld __cnfn convert_char2_rtp(char2);
+char2 __ovld __cnfn convert_char2_sat_rtp(char2);
+char2 __ovld __cnfn convert_char2_rtn(char2);
+char2 __ovld __cnfn convert_char2_sat_rtn(char2);
+char2 __ovld __cnfn convert_char2(char2);
+char2 __ovld __cnfn convert_char2_sat(char2);
+char2 __ovld __cnfn convert_char2_rte(uchar2);
+char2 __ovld __cnfn convert_char2_sat_rte(uchar2);
+char2 __ovld __cnfn convert_char2_rtz(uchar2);
+char2 __ovld __cnfn convert_char2_sat_rtz(uchar2);
+char2 __ovld __cnfn convert_char2_rtp(uchar2);
+char2 __ovld __cnfn convert_char2_sat_rtp(uchar2);
+char2 __ovld __cnfn convert_char2_rtn(uchar2);
+char2 __ovld __cnfn convert_char2_sat_rtn(uchar2);
+char2 __ovld __cnfn convert_char2(uchar2);
+char2 __ovld __cnfn convert_char2_sat(uchar2);
+char2 __ovld __cnfn convert_char2_rte(short2);
+char2 __ovld __cnfn convert_char2_sat_rte(short2);
+char2 __ovld __cnfn convert_char2_rtz(short2);
+char2 __ovld __cnfn convert_char2_sat_rtz(short2);
+char2 __ovld __cnfn convert_char2_rtp(short2);
+char2 __ovld __cnfn convert_char2_sat_rtp(short2);
+char2 __ovld __cnfn convert_char2_rtn(short2);
+char2 __ovld __cnfn convert_char2_sat_rtn(short2);
+char2 __ovld __cnfn convert_char2(short2);
+char2 __ovld __cnfn convert_char2_sat(short2);
+char2 __ovld __cnfn convert_char2_rte(ushort2);
+char2 __ovld __cnfn convert_char2_sat_rte(ushort2);
+char2 __ovld __cnfn convert_char2_rtz(ushort2);
+char2 __ovld __cnfn convert_char2_sat_rtz(ushort2);
+char2 __ovld __cnfn convert_char2_rtp(ushort2);
+char2 __ovld __cnfn convert_char2_sat_rtp(ushort2);
+char2 __ovld __cnfn convert_char2_rtn(ushort2);
+char2 __ovld __cnfn convert_char2_sat_rtn(ushort2);
+char2 __ovld __cnfn convert_char2(ushort2);
+char2 __ovld __cnfn convert_char2_sat(ushort2);
+char2 __ovld __cnfn convert_char2_rte(int2);
+char2 __ovld __cnfn convert_char2_sat_rte(int2);
+char2 __ovld __cnfn convert_char2_rtz(int2);
+char2 __ovld __cnfn convert_char2_sat_rtz(int2);
+char2 __ovld __cnfn convert_char2_rtp(int2);
+char2 __ovld __cnfn convert_char2_sat_rtp(int2);
+char2 __ovld __cnfn convert_char2_rtn(int2);
+char2 __ovld __cnfn convert_char2_sat_rtn(int2);
+char2 __ovld __cnfn convert_char2(int2);
+char2 __ovld __cnfn convert_char2_sat(int2);
+char2 __ovld __cnfn convert_char2_rte(uint2);
+char2 __ovld __cnfn convert_char2_sat_rte(uint2);
+char2 __ovld __cnfn convert_char2_rtz(uint2);
+char2 __ovld __cnfn convert_char2_sat_rtz(uint2);
+char2 __ovld __cnfn convert_char2_rtp(uint2);
+char2 __ovld __cnfn convert_char2_sat_rtp(uint2);
+char2 __ovld __cnfn convert_char2_rtn(uint2);
+char2 __ovld __cnfn convert_char2_sat_rtn(uint2);
+char2 __ovld __cnfn convert_char2(uint2);
+char2 __ovld __cnfn convert_char2_sat(uint2);
+char2 __ovld __cnfn convert_char2_rte(long2);
+char2 __ovld __cnfn convert_char2_sat_rte(long2);
+char2 __ovld __cnfn convert_char2_rtz(long2);
+char2 __ovld __cnfn convert_char2_sat_rtz(long2);
+char2 __ovld __cnfn convert_char2_rtp(long2);
+char2 __ovld __cnfn convert_char2_sat_rtp(long2);
+char2 __ovld __cnfn convert_char2_rtn(long2);
+char2 __ovld __cnfn convert_char2_sat_rtn(long2);
+char2 __ovld __cnfn convert_char2(long2);
+char2 __ovld __cnfn convert_char2_sat(long2);
+char2 __ovld __cnfn convert_char2_rte(ulong2);
+char2 __ovld __cnfn convert_char2_sat_rte(ulong2);
+char2 __ovld __cnfn convert_char2_rtz(ulong2);
+char2 __ovld __cnfn convert_char2_sat_rtz(ulong2);
+char2 __ovld __cnfn convert_char2_rtp(ulong2);
+char2 __ovld __cnfn convert_char2_sat_rtp(ulong2);
+char2 __ovld __cnfn convert_char2_rtn(ulong2);
+char2 __ovld __cnfn convert_char2_sat_rtn(ulong2);
+char2 __ovld __cnfn convert_char2(ulong2);
+char2 __ovld __cnfn convert_char2_sat(ulong2);
+char2 __ovld __cnfn convert_char2_rte(float2);
+char2 __ovld __cnfn convert_char2_sat_rte(float2);
+char2 __ovld __cnfn convert_char2_rtz(float2);
+char2 __ovld __cnfn convert_char2_sat_rtz(float2);
+char2 __ovld __cnfn convert_char2_rtp(float2);
+char2 __ovld __cnfn convert_char2_sat_rtp(float2);
+char2 __ovld __cnfn convert_char2_rtn(float2);
+char2 __ovld __cnfn convert_char2_sat_rtn(float2);
+char2 __ovld __cnfn convert_char2(float2);
+char2 __ovld __cnfn convert_char2_sat(float2);
+uchar2 __ovld __cnfn convert_uchar2_rte(char2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(char2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(char2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(char2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(char2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(char2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(char2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(char2);
+uchar2 __ovld __cnfn convert_uchar2(char2);
+uchar2 __ovld __cnfn convert_uchar2_sat(char2);
+uchar2 __ovld __cnfn convert_uchar2_rte(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(uchar2);
+uchar2 __ovld __cnfn convert_uchar2(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_sat(uchar2);
+uchar2 __ovld __cnfn convert_uchar2_rte(short2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(short2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(short2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(short2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(short2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(short2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(short2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(short2);
+uchar2 __ovld __cnfn convert_uchar2(short2);
+uchar2 __ovld __cnfn convert_uchar2_sat(short2);
+uchar2 __ovld __cnfn convert_uchar2_rte(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(ushort2);
+uchar2 __ovld __cnfn convert_uchar2(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_sat(ushort2);
+uchar2 __ovld __cnfn convert_uchar2_rte(int2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(int2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(int2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(int2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(int2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(int2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(int2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(int2);
+uchar2 __ovld __cnfn convert_uchar2(int2);
+uchar2 __ovld __cnfn convert_uchar2_sat(int2);
+uchar2 __ovld __cnfn convert_uchar2_rte(uint2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(uint2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(uint2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(uint2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(uint2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(uint2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(uint2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(uint2);
+uchar2 __ovld __cnfn convert_uchar2(uint2);
+uchar2 __ovld __cnfn convert_uchar2_sat(uint2);
+uchar2 __ovld __cnfn convert_uchar2_rte(long2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(long2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(long2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(long2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(long2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(long2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(long2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(long2);
+uchar2 __ovld __cnfn convert_uchar2(long2);
+uchar2 __ovld __cnfn convert_uchar2_sat(long2);
+uchar2 __ovld __cnfn convert_uchar2_rte(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(ulong2);
+uchar2 __ovld __cnfn convert_uchar2(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_sat(ulong2);
+uchar2 __ovld __cnfn convert_uchar2_rte(float2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(float2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(float2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(float2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(float2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(float2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(float2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(float2);
+uchar2 __ovld __cnfn convert_uchar2(float2);
+uchar2 __ovld __cnfn convert_uchar2_sat(float2);
+short2 __ovld __cnfn convert_short2_rte(char2);
+short2 __ovld __cnfn convert_short2_sat_rte(char2);
+short2 __ovld __cnfn convert_short2_rtz(char2);
+short2 __ovld __cnfn convert_short2_sat_rtz(char2);
+short2 __ovld __cnfn convert_short2_rtp(char2);
+short2 __ovld __cnfn convert_short2_sat_rtp(char2);
+short2 __ovld __cnfn convert_short2_rtn(char2);
+short2 __ovld __cnfn convert_short2_sat_rtn(char2);
+short2 __ovld __cnfn convert_short2(char2);
+short2 __ovld __cnfn convert_short2_sat(char2);
+short2 __ovld __cnfn convert_short2_rte(uchar2);
+short2 __ovld __cnfn convert_short2_sat_rte(uchar2);
+short2 __ovld __cnfn convert_short2_rtz(uchar2);
+short2 __ovld __cnfn convert_short2_sat_rtz(uchar2);
+short2 __ovld __cnfn convert_short2_rtp(uchar2);
+short2 __ovld __cnfn convert_short2_sat_rtp(uchar2);
+short2 __ovld __cnfn convert_short2_rtn(uchar2);
+short2 __ovld __cnfn convert_short2_sat_rtn(uchar2);
+short2 __ovld __cnfn convert_short2(uchar2);
+short2 __ovld __cnfn convert_short2_sat(uchar2);
+short2 __ovld __cnfn convert_short2_rte(short2);
+short2 __ovld __cnfn convert_short2_sat_rte(short2);
+short2 __ovld __cnfn convert_short2_rtz(short2);
+short2 __ovld __cnfn convert_short2_sat_rtz(short2);
+short2 __ovld __cnfn convert_short2_rtp(short2);
+short2 __ovld __cnfn convert_short2_sat_rtp(short2);
+short2 __ovld __cnfn convert_short2_rtn(short2);
+short2 __ovld __cnfn convert_short2_sat_rtn(short2);
+short2 __ovld __cnfn convert_short2(short2);
+short2 __ovld __cnfn convert_short2_sat(short2);
+short2 __ovld __cnfn convert_short2_rte(ushort2);
+short2 __ovld __cnfn convert_short2_sat_rte(ushort2);
+short2 __ovld __cnfn convert_short2_rtz(ushort2);
+short2 __ovld __cnfn convert_short2_sat_rtz(ushort2);
+short2 __ovld __cnfn convert_short2_rtp(ushort2);
+short2 __ovld __cnfn convert_short2_sat_rtp(ushort2);
+short2 __ovld __cnfn convert_short2_rtn(ushort2);
+short2 __ovld __cnfn convert_short2_sat_rtn(ushort2);
+short2 __ovld __cnfn convert_short2(ushort2);
+short2 __ovld __cnfn convert_short2_sat(ushort2);
+short2 __ovld __cnfn convert_short2_rte(int2);
+short2 __ovld __cnfn convert_short2_sat_rte(int2);
+short2 __ovld __cnfn convert_short2_rtz(int2);
+short2 __ovld __cnfn convert_short2_sat_rtz(int2);
+short2 __ovld __cnfn convert_short2_rtp(int2);
+short2 __ovld __cnfn convert_short2_sat_rtp(int2);
+short2 __ovld __cnfn convert_short2_rtn(int2);
+short2 __ovld __cnfn convert_short2_sat_rtn(int2);
+short2 __ovld __cnfn convert_short2(int2);
+short2 __ovld __cnfn convert_short2_sat(int2);
+short2 __ovld __cnfn convert_short2_rte(uint2);
+short2 __ovld __cnfn convert_short2_sat_rte(uint2);
+short2 __ovld __cnfn convert_short2_rtz(uint2);
+short2 __ovld __cnfn convert_short2_sat_rtz(uint2);
+short2 __ovld __cnfn convert_short2_rtp(uint2);
+short2 __ovld __cnfn convert_short2_sat_rtp(uint2);
+short2 __ovld __cnfn convert_short2_rtn(uint2);
+short2 __ovld __cnfn convert_short2_sat_rtn(uint2);
+short2 __ovld __cnfn convert_short2(uint2);
+short2 __ovld __cnfn convert_short2_sat(uint2);
+short2 __ovld __cnfn convert_short2_rte(long2);
+short2 __ovld __cnfn convert_short2_sat_rte(long2);
+short2 __ovld __cnfn convert_short2_rtz(long2);
+short2 __ovld __cnfn convert_short2_sat_rtz(long2);
+short2 __ovld __cnfn convert_short2_rtp(long2);
+short2 __ovld __cnfn convert_short2_sat_rtp(long2);
+short2 __ovld __cnfn convert_short2_rtn(long2);
+short2 __ovld __cnfn convert_short2_sat_rtn(long2);
+short2 __ovld __cnfn convert_short2(long2);
+short2 __ovld __cnfn convert_short2_sat(long2);
+short2 __ovld __cnfn convert_short2_rte(ulong2);
+short2 __ovld __cnfn convert_short2_sat_rte(ulong2);
+short2 __ovld __cnfn convert_short2_rtz(ulong2);
+short2 __ovld __cnfn convert_short2_sat_rtz(ulong2);
+short2 __ovld __cnfn convert_short2_rtp(ulong2);
+short2 __ovld __cnfn convert_short2_sat_rtp(ulong2);
+short2 __ovld __cnfn convert_short2_rtn(ulong2);
+short2 __ovld __cnfn convert_short2_sat_rtn(ulong2);
+short2 __ovld __cnfn convert_short2(ulong2);
+short2 __ovld __cnfn convert_short2_sat(ulong2);
+short2 __ovld __cnfn convert_short2_rte(float2);
+short2 __ovld __cnfn convert_short2_sat_rte(float2);
+short2 __ovld __cnfn convert_short2_rtz(float2);
+short2 __ovld __cnfn convert_short2_sat_rtz(float2);
+short2 __ovld __cnfn convert_short2_rtp(float2);
+short2 __ovld __cnfn convert_short2_sat_rtp(float2);
+short2 __ovld __cnfn convert_short2_rtn(float2);
+short2 __ovld __cnfn convert_short2_sat_rtn(float2);
+short2 __ovld __cnfn convert_short2(float2);
+short2 __ovld __cnfn convert_short2_sat(float2);
+ushort2 __ovld __cnfn convert_ushort2_rte(char2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(char2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(char2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(char2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(char2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(char2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(char2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(char2);
+ushort2 __ovld __cnfn convert_ushort2(char2);
+ushort2 __ovld __cnfn convert_ushort2_sat(char2);
+ushort2 __ovld __cnfn convert_ushort2_rte(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(uchar2);
+ushort2 __ovld __cnfn convert_ushort2(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_sat(uchar2);
+ushort2 __ovld __cnfn convert_ushort2_rte(short2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(short2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(short2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(short2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(short2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(short2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(short2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(short2);
+ushort2 __ovld __cnfn convert_ushort2(short2);
+ushort2 __ovld __cnfn convert_ushort2_sat(short2);
+ushort2 __ovld __cnfn convert_ushort2_rte(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(ushort2);
+ushort2 __ovld __cnfn convert_ushort2(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_sat(ushort2);
+ushort2 __ovld __cnfn convert_ushort2_rte(int2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(int2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(int2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(int2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(int2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(int2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(int2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(int2);
+ushort2 __ovld __cnfn convert_ushort2(int2);
+ushort2 __ovld __cnfn convert_ushort2_sat(int2);
+ushort2 __ovld __cnfn convert_ushort2_rte(uint2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(uint2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(uint2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(uint2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(uint2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(uint2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(uint2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(uint2);
+ushort2 __ovld __cnfn convert_ushort2(uint2);
+ushort2 __ovld __cnfn convert_ushort2_sat(uint2);
+ushort2 __ovld __cnfn convert_ushort2_rte(long2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(long2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(long2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(long2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(long2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(long2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(long2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(long2);
+ushort2 __ovld __cnfn convert_ushort2(long2);
+ushort2 __ovld __cnfn convert_ushort2_sat(long2);
+ushort2 __ovld __cnfn convert_ushort2_rte(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(ulong2);
+ushort2 __ovld __cnfn convert_ushort2(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_sat(ulong2);
+ushort2 __ovld __cnfn convert_ushort2_rte(float2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(float2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(float2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(float2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(float2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(float2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(float2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(float2);
+ushort2 __ovld __cnfn convert_ushort2(float2);
+ushort2 __ovld __cnfn convert_ushort2_sat(float2);
+int2 __ovld __cnfn convert_int2_rte(char2);
+int2 __ovld __cnfn convert_int2_sat_rte(char2);
+int2 __ovld __cnfn convert_int2_rtz(char2);
+int2 __ovld __cnfn convert_int2_sat_rtz(char2);
+int2 __ovld __cnfn convert_int2_rtp(char2);
+int2 __ovld __cnfn convert_int2_sat_rtp(char2);
+int2 __ovld __cnfn convert_int2_rtn(char2);
+int2 __ovld __cnfn convert_int2_sat_rtn(char2);
+int2 __ovld __cnfn convert_int2(char2);
+int2 __ovld __cnfn convert_int2_sat(char2);
+int2 __ovld __cnfn convert_int2_rte(uchar2);
+int2 __ovld __cnfn convert_int2_sat_rte(uchar2);
+int2 __ovld __cnfn convert_int2_rtz(uchar2);
+int2 __ovld __cnfn convert_int2_sat_rtz(uchar2);
+int2 __ovld __cnfn convert_int2_rtp(uchar2);
+int2 __ovld __cnfn convert_int2_sat_rtp(uchar2);
+int2 __ovld __cnfn convert_int2_rtn(uchar2);
+int2 __ovld __cnfn convert_int2_sat_rtn(uchar2);
+int2 __ovld __cnfn convert_int2(uchar2);
+int2 __ovld __cnfn convert_int2_sat(uchar2);
+int2 __ovld __cnfn convert_int2_rte(short2);
+int2 __ovld __cnfn convert_int2_sat_rte(short2);
+int2 __ovld __cnfn convert_int2_rtz(short2);
+int2 __ovld __cnfn convert_int2_sat_rtz(short2);
+int2 __ovld __cnfn convert_int2_rtp(short2);
+int2 __ovld __cnfn convert_int2_sat_rtp(short2);
+int2 __ovld __cnfn convert_int2_rtn(short2);
+int2 __ovld __cnfn convert_int2_sat_rtn(short2);
+int2 __ovld __cnfn convert_int2(short2);
+int2 __ovld __cnfn convert_int2_sat(short2);
+int2 __ovld __cnfn convert_int2_rte(ushort2);
+int2 __ovld __cnfn convert_int2_sat_rte(ushort2);
+int2 __ovld __cnfn convert_int2_rtz(ushort2);
+int2 __ovld __cnfn convert_int2_sat_rtz(ushort2);
+int2 __ovld __cnfn convert_int2_rtp(ushort2);
+int2 __ovld __cnfn convert_int2_sat_rtp(ushort2);
+int2 __ovld __cnfn convert_int2_rtn(ushort2);
+int2 __ovld __cnfn convert_int2_sat_rtn(ushort2);
+int2 __ovld __cnfn convert_int2(ushort2);
+int2 __ovld __cnfn convert_int2_sat(ushort2);
+int2 __ovld __cnfn convert_int2_rte(int2);
+int2 __ovld __cnfn convert_int2_sat_rte(int2);
+int2 __ovld __cnfn convert_int2_rtz(int2);
+int2 __ovld __cnfn convert_int2_sat_rtz(int2);
+int2 __ovld __cnfn convert_int2_rtp(int2);
+int2 __ovld __cnfn convert_int2_sat_rtp(int2);
+int2 __ovld __cnfn convert_int2_rtn(int2);
+int2 __ovld __cnfn convert_int2_sat_rtn(int2);
+int2 __ovld __cnfn convert_int2(int2);
+int2 __ovld __cnfn convert_int2_sat(int2);
+int2 __ovld __cnfn convert_int2_rte(uint2);
+int2 __ovld __cnfn convert_int2_sat_rte(uint2);
+int2 __ovld __cnfn convert_int2_rtz(uint2);
+int2 __ovld __cnfn convert_int2_sat_rtz(uint2);
+int2 __ovld __cnfn convert_int2_rtp(uint2);
+int2 __ovld __cnfn convert_int2_sat_rtp(uint2);
+int2 __ovld __cnfn convert_int2_rtn(uint2);
+int2 __ovld __cnfn convert_int2_sat_rtn(uint2);
+int2 __ovld __cnfn convert_int2(uint2);
+int2 __ovld __cnfn convert_int2_sat(uint2);
+int2 __ovld __cnfn convert_int2_rte(long2);
+int2 __ovld __cnfn convert_int2_sat_rte(long2);
+int2 __ovld __cnfn convert_int2_rtz(long2);
+int2 __ovld __cnfn convert_int2_sat_rtz(long2);
+int2 __ovld __cnfn convert_int2_rtp(long2);
+int2 __ovld __cnfn convert_int2_sat_rtp(long2);
+int2 __ovld __cnfn convert_int2_rtn(long2);
+int2 __ovld __cnfn convert_int2_sat_rtn(long2);
+int2 __ovld __cnfn convert_int2(long2);
+int2 __ovld __cnfn convert_int2_sat(long2);
+int2 __ovld __cnfn convert_int2_rte(ulong2);
+int2 __ovld __cnfn convert_int2_sat_rte(ulong2);
+int2 __ovld __cnfn convert_int2_rtz(ulong2);
+int2 __ovld __cnfn convert_int2_sat_rtz(ulong2);
+int2 __ovld __cnfn convert_int2_rtp(ulong2);
+int2 __ovld __cnfn convert_int2_sat_rtp(ulong2);
+int2 __ovld __cnfn convert_int2_rtn(ulong2);
+int2 __ovld __cnfn convert_int2_sat_rtn(ulong2);
+int2 __ovld __cnfn convert_int2(ulong2);
+int2 __ovld __cnfn convert_int2_sat(ulong2);
+int2 __ovld __cnfn convert_int2_rte(float2);
+int2 __ovld __cnfn convert_int2_sat_rte(float2);
+int2 __ovld __cnfn convert_int2_rtz(float2);
+int2 __ovld __cnfn convert_int2_sat_rtz(float2);
+int2 __ovld __cnfn convert_int2_rtp(float2);
+int2 __ovld __cnfn convert_int2_sat_rtp(float2);
+int2 __ovld __cnfn convert_int2_rtn(float2);
+int2 __ovld __cnfn convert_int2_sat_rtn(float2);
+int2 __ovld __cnfn convert_int2(float2);
+int2 __ovld __cnfn convert_int2_sat(float2);
+uint2 __ovld __cnfn convert_uint2_rte(char2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(char2);
+uint2 __ovld __cnfn convert_uint2_rtz(char2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(char2);
+uint2 __ovld __cnfn convert_uint2_rtp(char2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(char2);
+uint2 __ovld __cnfn convert_uint2_rtn(char2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(char2);
+uint2 __ovld __cnfn convert_uint2(char2);
+uint2 __ovld __cnfn convert_uint2_sat(char2);
+uint2 __ovld __cnfn convert_uint2_rte(uchar2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(uchar2);
+uint2 __ovld __cnfn convert_uint2_rtz(uchar2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(uchar2);
+uint2 __ovld __cnfn convert_uint2_rtp(uchar2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(uchar2);
+uint2 __ovld __cnfn convert_uint2_rtn(uchar2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(uchar2);
+uint2 __ovld __cnfn convert_uint2(uchar2);
+uint2 __ovld __cnfn convert_uint2_sat(uchar2);
+uint2 __ovld __cnfn convert_uint2_rte(short2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(short2);
+uint2 __ovld __cnfn convert_uint2_rtz(short2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(short2);
+uint2 __ovld __cnfn convert_uint2_rtp(short2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(short2);
+uint2 __ovld __cnfn convert_uint2_rtn(short2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(short2);
+uint2 __ovld __cnfn convert_uint2(short2);
+uint2 __ovld __cnfn convert_uint2_sat(short2);
+uint2 __ovld __cnfn convert_uint2_rte(ushort2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(ushort2);
+uint2 __ovld __cnfn convert_uint2_rtz(ushort2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(ushort2);
+uint2 __ovld __cnfn convert_uint2_rtp(ushort2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(ushort2);
+uint2 __ovld __cnfn convert_uint2_rtn(ushort2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(ushort2);
+uint2 __ovld __cnfn convert_uint2(ushort2);
+uint2 __ovld __cnfn convert_uint2_sat(ushort2);
+uint2 __ovld __cnfn convert_uint2_rte(int2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(int2);
+uint2 __ovld __cnfn convert_uint2_rtz(int2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(int2);
+uint2 __ovld __cnfn convert_uint2_rtp(int2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(int2);
+uint2 __ovld __cnfn convert_uint2_rtn(int2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(int2);
+uint2 __ovld __cnfn convert_uint2(int2);
+uint2 __ovld __cnfn convert_uint2_sat(int2);
+uint2 __ovld __cnfn convert_uint2_rte(uint2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(uint2);
+uint2 __ovld __cnfn convert_uint2_rtz(uint2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(uint2);
+uint2 __ovld __cnfn convert_uint2_rtp(uint2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(uint2);
+uint2 __ovld __cnfn convert_uint2_rtn(uint2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(uint2);
+uint2 __ovld __cnfn convert_uint2(uint2);
+uint2 __ovld __cnfn convert_uint2_sat(uint2);
+uint2 __ovld __cnfn convert_uint2_rte(long2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(long2);
+uint2 __ovld __cnfn convert_uint2_rtz(long2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(long2);
+uint2 __ovld __cnfn convert_uint2_rtp(long2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(long2);
+uint2 __ovld __cnfn convert_uint2_rtn(long2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(long2);
+uint2 __ovld __cnfn convert_uint2(long2);
+uint2 __ovld __cnfn convert_uint2_sat(long2);
+uint2 __ovld __cnfn convert_uint2_rte(ulong2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(ulong2);
+uint2 __ovld __cnfn convert_uint2_rtz(ulong2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(ulong2);
+uint2 __ovld __cnfn convert_uint2_rtp(ulong2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(ulong2);
+uint2 __ovld __cnfn convert_uint2_rtn(ulong2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(ulong2);
+uint2 __ovld __cnfn convert_uint2(ulong2);
+uint2 __ovld __cnfn convert_uint2_sat(ulong2);
+uint2 __ovld __cnfn convert_uint2_rte(float2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(float2);
+uint2 __ovld __cnfn convert_uint2_rtz(float2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(float2);
+uint2 __ovld __cnfn convert_uint2_rtp(float2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(float2);
+uint2 __ovld __cnfn convert_uint2_rtn(float2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(float2);
+uint2 __ovld __cnfn convert_uint2(float2);
+uint2 __ovld __cnfn convert_uint2_sat(float2);
+long2 __ovld __cnfn convert_long2_rte(char2);
+long2 __ovld __cnfn convert_long2_sat_rte(char2);
+long2 __ovld __cnfn convert_long2_rtz(char2);
+long2 __ovld __cnfn convert_long2_sat_rtz(char2);
+long2 __ovld __cnfn convert_long2_rtp(char2);
+long2 __ovld __cnfn convert_long2_sat_rtp(char2);
+long2 __ovld __cnfn convert_long2_rtn(char2);
+long2 __ovld __cnfn convert_long2_sat_rtn(char2);
+long2 __ovld __cnfn convert_long2(char2);
+long2 __ovld __cnfn convert_long2_sat(char2);
+long2 __ovld __cnfn convert_long2_rte(uchar2);
+long2 __ovld __cnfn convert_long2_sat_rte(uchar2);
+long2 __ovld __cnfn convert_long2_rtz(uchar2);
+long2 __ovld __cnfn convert_long2_sat_rtz(uchar2);
+long2 __ovld __cnfn convert_long2_rtp(uchar2);
+long2 __ovld __cnfn convert_long2_sat_rtp(uchar2);
+long2 __ovld __cnfn convert_long2_rtn(uchar2);
+long2 __ovld __cnfn convert_long2_sat_rtn(uchar2);
+long2 __ovld __cnfn convert_long2(uchar2);
+long2 __ovld __cnfn convert_long2_sat(uchar2);
+long2 __ovld __cnfn convert_long2_rte(short2);
+long2 __ovld __cnfn convert_long2_sat_rte(short2);
+long2 __ovld __cnfn convert_long2_rtz(short2);
+long2 __ovld __cnfn convert_long2_sat_rtz(short2);
+long2 __ovld __cnfn convert_long2_rtp(short2);
+long2 __ovld __cnfn convert_long2_sat_rtp(short2);
+long2 __ovld __cnfn convert_long2_rtn(short2);
+long2 __ovld __cnfn convert_long2_sat_rtn(short2);
+long2 __ovld __cnfn convert_long2(short2);
+long2 __ovld __cnfn convert_long2_sat(short2);
+long2 __ovld __cnfn convert_long2_rte(ushort2);
+long2 __ovld __cnfn convert_long2_sat_rte(ushort2);
+long2 __ovld __cnfn convert_long2_rtz(ushort2);
+long2 __ovld __cnfn convert_long2_sat_rtz(ushort2);
+long2 __ovld __cnfn convert_long2_rtp(ushort2);
+long2 __ovld __cnfn convert_long2_sat_rtp(ushort2);
+long2 __ovld __cnfn convert_long2_rtn(ushort2);
+long2 __ovld __cnfn convert_long2_sat_rtn(ushort2);
+long2 __ovld __cnfn convert_long2(ushort2);
+long2 __ovld __cnfn convert_long2_sat(ushort2);
+long2 __ovld __cnfn convert_long2_rte(int2);
+long2 __ovld __cnfn convert_long2_sat_rte(int2);
+long2 __ovld __cnfn convert_long2_rtz(int2);
+long2 __ovld __cnfn convert_long2_sat_rtz(int2);
+long2 __ovld __cnfn convert_long2_rtp(int2);
+long2 __ovld __cnfn convert_long2_sat_rtp(int2);
+long2 __ovld __cnfn convert_long2_rtn(int2);
+long2 __ovld __cnfn convert_long2_sat_rtn(int2);
+long2 __ovld __cnfn convert_long2(int2);
+long2 __ovld __cnfn convert_long2_sat(int2);
+long2 __ovld __cnfn convert_long2_rte(uint2);
+long2 __ovld __cnfn convert_long2_sat_rte(uint2);
+long2 __ovld __cnfn convert_long2_rtz(uint2);
+long2 __ovld __cnfn convert_long2_sat_rtz(uint2);
+long2 __ovld __cnfn convert_long2_rtp(uint2);
+long2 __ovld __cnfn convert_long2_sat_rtp(uint2);
+long2 __ovld __cnfn convert_long2_rtn(uint2);
+long2 __ovld __cnfn convert_long2_sat_rtn(uint2);
+long2 __ovld __cnfn convert_long2(uint2);
+long2 __ovld __cnfn convert_long2_sat(uint2);
+long2 __ovld __cnfn convert_long2_rte(long2);
+long2 __ovld __cnfn convert_long2_sat_rte(long2);
+long2 __ovld __cnfn convert_long2_rtz(long2);
+long2 __ovld __cnfn convert_long2_sat_rtz(long2);
+long2 __ovld __cnfn convert_long2_rtp(long2);
+long2 __ovld __cnfn convert_long2_sat_rtp(long2);
+long2 __ovld __cnfn convert_long2_rtn(long2);
+long2 __ovld __cnfn convert_long2_sat_rtn(long2);
+long2 __ovld __cnfn convert_long2(long2);
+long2 __ovld __cnfn convert_long2_sat(long2);
+long2 __ovld __cnfn convert_long2_rte(ulong2);
+long2 __ovld __cnfn convert_long2_sat_rte(ulong2);
+long2 __ovld __cnfn convert_long2_rtz(ulong2);
+long2 __ovld __cnfn convert_long2_sat_rtz(ulong2);
+long2 __ovld __cnfn convert_long2_rtp(ulong2);
+long2 __ovld __cnfn convert_long2_sat_rtp(ulong2);
+long2 __ovld __cnfn convert_long2_rtn(ulong2);
+long2 __ovld __cnfn convert_long2_sat_rtn(ulong2);
+long2 __ovld __cnfn convert_long2(ulong2);
+long2 __ovld __cnfn convert_long2_sat(ulong2);
+long2 __ovld __cnfn convert_long2_rte(float2);
+long2 __ovld __cnfn convert_long2_sat_rte(float2);
+long2 __ovld __cnfn convert_long2_rtz(float2);
+long2 __ovld __cnfn convert_long2_sat_rtz(float2);
+long2 __ovld __cnfn convert_long2_rtp(float2);
+long2 __ovld __cnfn convert_long2_sat_rtp(float2);
+long2 __ovld __cnfn convert_long2_rtn(float2);
+long2 __ovld __cnfn convert_long2_sat_rtn(float2);
+long2 __ovld __cnfn convert_long2(float2);
+long2 __ovld __cnfn convert_long2_sat(float2);
+ulong2 __ovld __cnfn convert_ulong2_rte(char2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(char2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(char2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(char2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(char2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(char2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(char2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(char2);
+ulong2 __ovld __cnfn convert_ulong2(char2);
+ulong2 __ovld __cnfn convert_ulong2_sat(char2);
+ulong2 __ovld __cnfn convert_ulong2_rte(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(uchar2);
+ulong2 __ovld __cnfn convert_ulong2(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_sat(uchar2);
+ulong2 __ovld __cnfn convert_ulong2_rte(short2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(short2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(short2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(short2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(short2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(short2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(short2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(short2);
+ulong2 __ovld __cnfn convert_ulong2(short2);
+ulong2 __ovld __cnfn convert_ulong2_sat(short2);
+ulong2 __ovld __cnfn convert_ulong2_rte(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(ushort2);
+ulong2 __ovld __cnfn convert_ulong2(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_sat(ushort2);
+ulong2 __ovld __cnfn convert_ulong2_rte(int2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(int2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(int2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(int2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(int2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(int2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(int2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(int2);
+ulong2 __ovld __cnfn convert_ulong2(int2);
+ulong2 __ovld __cnfn convert_ulong2_sat(int2);
+ulong2 __ovld __cnfn convert_ulong2_rte(uint2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(uint2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(uint2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(uint2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(uint2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(uint2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(uint2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(uint2);
+ulong2 __ovld __cnfn convert_ulong2(uint2);
+ulong2 __ovld __cnfn convert_ulong2_sat(uint2);
+ulong2 __ovld __cnfn convert_ulong2_rte(long2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(long2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(long2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(long2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(long2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(long2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(long2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(long2);
+ulong2 __ovld __cnfn convert_ulong2(long2);
+ulong2 __ovld __cnfn convert_ulong2_sat(long2);
+ulong2 __ovld __cnfn convert_ulong2_rte(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(ulong2);
+ulong2 __ovld __cnfn convert_ulong2(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_sat(ulong2);
+ulong2 __ovld __cnfn convert_ulong2_rte(float2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(float2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(float2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(float2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(float2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(float2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(float2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(float2);
+ulong2 __ovld __cnfn convert_ulong2(float2);
+ulong2 __ovld __cnfn convert_ulong2_sat(float2);
+float2 __ovld __cnfn convert_float2_rte(char2);
+float2 __ovld __cnfn convert_float2_rtz(char2);
+float2 __ovld __cnfn convert_float2_rtp(char2);
+float2 __ovld __cnfn convert_float2_rtn(char2);
+float2 __ovld __cnfn convert_float2(char2);
+float2 __ovld __cnfn convert_float2_rte(uchar2);
+float2 __ovld __cnfn convert_float2_rtz(uchar2);
+float2 __ovld __cnfn convert_float2_rtp(uchar2);
+float2 __ovld __cnfn convert_float2_rtn(uchar2);
+float2 __ovld __cnfn convert_float2(uchar2);
+float2 __ovld __cnfn convert_float2_rte(short2);
+float2 __ovld __cnfn convert_float2_rtz(short2);
+float2 __ovld __cnfn convert_float2_rtp(short2);
+float2 __ovld __cnfn convert_float2_rtn(short2);
+float2 __ovld __cnfn convert_float2(short2);
+float2 __ovld __cnfn convert_float2_rte(ushort2);
+float2 __ovld __cnfn convert_float2_rtz(ushort2);
+float2 __ovld __cnfn convert_float2_rtp(ushort2);
+float2 __ovld __cnfn convert_float2_rtn(ushort2);
+float2 __ovld __cnfn convert_float2(ushort2);
+float2 __ovld __cnfn convert_float2_rte(int2);
+float2 __ovld __cnfn convert_float2_rtz(int2);
+float2 __ovld __cnfn convert_float2_rtp(int2);
+float2 __ovld __cnfn convert_float2_rtn(int2);
+float2 __ovld __cnfn convert_float2(int2);
+float2 __ovld __cnfn convert_float2_rte(uint2);
+float2 __ovld __cnfn convert_float2_rtz(uint2);
+float2 __ovld __cnfn convert_float2_rtp(uint2);
+float2 __ovld __cnfn convert_float2_rtn(uint2);
+float2 __ovld __cnfn convert_float2(uint2);
+float2 __ovld __cnfn convert_float2_rte(long2);
+float2 __ovld __cnfn convert_float2_rtz(long2);
+float2 __ovld __cnfn convert_float2_rtp(long2);
+float2 __ovld __cnfn convert_float2_rtn(long2);
+float2 __ovld __cnfn convert_float2(long2);
+float2 __ovld __cnfn convert_float2_rte(ulong2);
+float2 __ovld __cnfn convert_float2_rtz(ulong2);
+float2 __ovld __cnfn convert_float2_rtp(ulong2);
+float2 __ovld __cnfn convert_float2_rtn(ulong2);
+float2 __ovld __cnfn convert_float2(ulong2);
+float2 __ovld __cnfn convert_float2_rte(float2);
+float2 __ovld __cnfn convert_float2_rtz(float2);
+float2 __ovld __cnfn convert_float2_rtp(float2);
+float2 __ovld __cnfn convert_float2_rtn(float2);
+float2 __ovld __cnfn convert_float2(float2);
+char3 __ovld __cnfn convert_char3_rte(char3);
+char3 __ovld __cnfn convert_char3_sat_rte(char3);
+char3 __ovld __cnfn convert_char3_rtz(char3);
+char3 __ovld __cnfn convert_char3_sat_rtz(char3);
+char3 __ovld __cnfn convert_char3_rtp(char3);
+char3 __ovld __cnfn convert_char3_sat_rtp(char3);
+char3 __ovld __cnfn convert_char3_rtn(char3);
+char3 __ovld __cnfn convert_char3_sat_rtn(char3);
+char3 __ovld __cnfn convert_char3(char3);
+char3 __ovld __cnfn convert_char3_sat(char3);
+char3 __ovld __cnfn convert_char3_rte(uchar3);
+char3 __ovld __cnfn convert_char3_sat_rte(uchar3);
+char3 __ovld __cnfn convert_char3_rtz(uchar3);
+char3 __ovld __cnfn convert_char3_sat_rtz(uchar3);
+char3 __ovld __cnfn convert_char3_rtp(uchar3);
+char3 __ovld __cnfn convert_char3_sat_rtp(uchar3);
+char3 __ovld __cnfn convert_char3_rtn(uchar3);
+char3 __ovld __cnfn convert_char3_sat_rtn(uchar3);
+char3 __ovld __cnfn convert_char3(uchar3);
+char3 __ovld __cnfn convert_char3_sat(uchar3);
+char3 __ovld __cnfn convert_char3_rte(short3);
+char3 __ovld __cnfn convert_char3_sat_rte(short3);
+char3 __ovld __cnfn convert_char3_rtz(short3);
+char3 __ovld __cnfn convert_char3_sat_rtz(short3);
+char3 __ovld __cnfn convert_char3_rtp(short3);
+char3 __ovld __cnfn convert_char3_sat_rtp(short3);
+char3 __ovld __cnfn convert_char3_rtn(short3);
+char3 __ovld __cnfn convert_char3_sat_rtn(short3);
+char3 __ovld __cnfn convert_char3(short3);
+char3 __ovld __cnfn convert_char3_sat(short3);
+char3 __ovld __cnfn convert_char3_rte(ushort3);
+char3 __ovld __cnfn convert_char3_sat_rte(ushort3);
+char3 __ovld __cnfn convert_char3_rtz(ushort3);
+char3 __ovld __cnfn convert_char3_sat_rtz(ushort3);
+char3 __ovld __cnfn convert_char3_rtp(ushort3);
+char3 __ovld __cnfn convert_char3_sat_rtp(ushort3);
+char3 __ovld __cnfn convert_char3_rtn(ushort3);
+char3 __ovld __cnfn convert_char3_sat_rtn(ushort3);
+char3 __ovld __cnfn convert_char3(ushort3);
+char3 __ovld __cnfn convert_char3_sat(ushort3);
+char3 __ovld __cnfn convert_char3_rte(int3);
+char3 __ovld __cnfn convert_char3_sat_rte(int3);
+char3 __ovld __cnfn convert_char3_rtz(int3);
+char3 __ovld __cnfn convert_char3_sat_rtz(int3);
+char3 __ovld __cnfn convert_char3_rtp(int3);
+char3 __ovld __cnfn convert_char3_sat_rtp(int3);
+char3 __ovld __cnfn convert_char3_rtn(int3);
+char3 __ovld __cnfn convert_char3_sat_rtn(int3);
+char3 __ovld __cnfn convert_char3(int3);
+char3 __ovld __cnfn convert_char3_sat(int3);
+char3 __ovld __cnfn convert_char3_rte(uint3);
+char3 __ovld __cnfn convert_char3_sat_rte(uint3);
+char3 __ovld __cnfn convert_char3_rtz(uint3);
+char3 __ovld __cnfn convert_char3_sat_rtz(uint3);
+char3 __ovld __cnfn convert_char3_rtp(uint3);
+char3 __ovld __cnfn convert_char3_sat_rtp(uint3);
+char3 __ovld __cnfn convert_char3_rtn(uint3);
+char3 __ovld __cnfn convert_char3_sat_rtn(uint3);
+char3 __ovld __cnfn convert_char3(uint3);
+char3 __ovld __cnfn convert_char3_sat(uint3);
+char3 __ovld __cnfn convert_char3_rte(long3);
+char3 __ovld __cnfn convert_char3_sat_rte(long3);
+char3 __ovld __cnfn convert_char3_rtz(long3);
+char3 __ovld __cnfn convert_char3_sat_rtz(long3);
+char3 __ovld __cnfn convert_char3_rtp(long3);
+char3 __ovld __cnfn convert_char3_sat_rtp(long3);
+char3 __ovld __cnfn convert_char3_rtn(long3);
+char3 __ovld __cnfn convert_char3_sat_rtn(long3);
+char3 __ovld __cnfn convert_char3(long3);
+char3 __ovld __cnfn convert_char3_sat(long3);
+char3 __ovld __cnfn convert_char3_rte(ulong3);
+char3 __ovld __cnfn convert_char3_sat_rte(ulong3);
+char3 __ovld __cnfn convert_char3_rtz(ulong3);
+char3 __ovld __cnfn convert_char3_sat_rtz(ulong3);
+char3 __ovld __cnfn convert_char3_rtp(ulong3);
+char3 __ovld __cnfn convert_char3_sat_rtp(ulong3);
+char3 __ovld __cnfn convert_char3_rtn(ulong3);
+char3 __ovld __cnfn convert_char3_sat_rtn(ulong3);
+char3 __ovld __cnfn convert_char3(ulong3);
+char3 __ovld __cnfn convert_char3_sat(ulong3);
+char3 __ovld __cnfn convert_char3_rte(float3);
+char3 __ovld __cnfn convert_char3_sat_rte(float3);
+char3 __ovld __cnfn convert_char3_rtz(float3);
+char3 __ovld __cnfn convert_char3_sat_rtz(float3);
+char3 __ovld __cnfn convert_char3_rtp(float3);
+char3 __ovld __cnfn convert_char3_sat_rtp(float3);
+char3 __ovld __cnfn convert_char3_rtn(float3);
+char3 __ovld __cnfn convert_char3_sat_rtn(float3);
+char3 __ovld __cnfn convert_char3(float3);
+char3 __ovld __cnfn convert_char3_sat(float3);
+uchar3 __ovld __cnfn convert_uchar3_rte(char3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(char3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(char3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(char3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(char3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(char3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(char3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(char3);
+uchar3 __ovld __cnfn convert_uchar3(char3);
+uchar3 __ovld __cnfn convert_uchar3_sat(char3);
+uchar3 __ovld __cnfn convert_uchar3_rte(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(uchar3);
+uchar3 __ovld __cnfn convert_uchar3(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_sat(uchar3);
+uchar3 __ovld __cnfn convert_uchar3_rte(short3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(short3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(short3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(short3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(short3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(short3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(short3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(short3);
+uchar3 __ovld __cnfn convert_uchar3(short3);
+uchar3 __ovld __cnfn convert_uchar3_sat(short3);
+uchar3 __ovld __cnfn convert_uchar3_rte(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(ushort3);
+uchar3 __ovld __cnfn convert_uchar3(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_sat(ushort3);
+uchar3 __ovld __cnfn convert_uchar3_rte(int3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(int3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(int3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(int3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(int3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(int3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(int3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(int3);
+uchar3 __ovld __cnfn convert_uchar3(int3);
+uchar3 __ovld __cnfn convert_uchar3_sat(int3);
+uchar3 __ovld __cnfn convert_uchar3_rte(uint3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(uint3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(uint3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(uint3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(uint3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(uint3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(uint3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(uint3);
+uchar3 __ovld __cnfn convert_uchar3(uint3);
+uchar3 __ovld __cnfn convert_uchar3_sat(uint3);
+uchar3 __ovld __cnfn convert_uchar3_rte(long3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(long3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(long3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(long3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(long3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(long3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(long3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(long3);
+uchar3 __ovld __cnfn convert_uchar3(long3);
+uchar3 __ovld __cnfn convert_uchar3_sat(long3);
+uchar3 __ovld __cnfn convert_uchar3_rte(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(ulong3);
+uchar3 __ovld __cnfn convert_uchar3(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_sat(ulong3);
+uchar3 __ovld __cnfn convert_uchar3_rte(float3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(float3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(float3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(float3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(float3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(float3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(float3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(float3);
+uchar3 __ovld __cnfn convert_uchar3(float3);
+uchar3 __ovld __cnfn convert_uchar3_sat(float3);
+short3 __ovld __cnfn convert_short3_rte(char3);
+short3 __ovld __cnfn convert_short3_sat_rte(char3);
+short3 __ovld __cnfn convert_short3_rtz(char3);
+short3 __ovld __cnfn convert_short3_sat_rtz(char3);
+short3 __ovld __cnfn convert_short3_rtp(char3);
+short3 __ovld __cnfn convert_short3_sat_rtp(char3);
+short3 __ovld __cnfn convert_short3_rtn(char3);
+short3 __ovld __cnfn convert_short3_sat_rtn(char3);
+short3 __ovld __cnfn convert_short3(char3);
+short3 __ovld __cnfn convert_short3_sat(char3);
+short3 __ovld __cnfn convert_short3_rte(uchar3);
+short3 __ovld __cnfn convert_short3_sat_rte(uchar3);
+short3 __ovld __cnfn convert_short3_rtz(uchar3);
+short3 __ovld __cnfn convert_short3_sat_rtz(uchar3);
+short3 __ovld __cnfn convert_short3_rtp(uchar3);
+short3 __ovld __cnfn convert_short3_sat_rtp(uchar3);
+short3 __ovld __cnfn convert_short3_rtn(uchar3);
+short3 __ovld __cnfn convert_short3_sat_rtn(uchar3);
+short3 __ovld __cnfn convert_short3(uchar3);
+short3 __ovld __cnfn convert_short3_sat(uchar3);
+short3 __ovld __cnfn convert_short3_rte(short3);
+short3 __ovld __cnfn convert_short3_sat_rte(short3);
+short3 __ovld __cnfn convert_short3_rtz(short3);
+short3 __ovld __cnfn convert_short3_sat_rtz(short3);
+short3 __ovld __cnfn convert_short3_rtp(short3);
+short3 __ovld __cnfn convert_short3_sat_rtp(short3);
+short3 __ovld __cnfn convert_short3_rtn(short3);
+short3 __ovld __cnfn convert_short3_sat_rtn(short3);
+short3 __ovld __cnfn convert_short3(short3);
+short3 __ovld __cnfn convert_short3_sat(short3);
+short3 __ovld __cnfn convert_short3_rte(ushort3);
+short3 __ovld __cnfn convert_short3_sat_rte(ushort3);
+short3 __ovld __cnfn convert_short3_rtz(ushort3);
+short3 __ovld __cnfn convert_short3_sat_rtz(ushort3);
+short3 __ovld __cnfn convert_short3_rtp(ushort3);
+short3 __ovld __cnfn convert_short3_sat_rtp(ushort3);
+short3 __ovld __cnfn convert_short3_rtn(ushort3);
+short3 __ovld __cnfn convert_short3_sat_rtn(ushort3);
+short3 __ovld __cnfn convert_short3(ushort3);
+short3 __ovld __cnfn convert_short3_sat(ushort3);
+short3 __ovld __cnfn convert_short3_rte(int3);
+short3 __ovld __cnfn convert_short3_sat_rte(int3);
+short3 __ovld __cnfn convert_short3_rtz(int3);
+short3 __ovld __cnfn convert_short3_sat_rtz(int3);
+short3 __ovld __cnfn convert_short3_rtp(int3);
+short3 __ovld __cnfn convert_short3_sat_rtp(int3);
+short3 __ovld __cnfn convert_short3_rtn(int3);
+short3 __ovld __cnfn convert_short3_sat_rtn(int3);
+short3 __ovld __cnfn convert_short3(int3);
+short3 __ovld __cnfn convert_short3_sat(int3);
+short3 __ovld __cnfn convert_short3_rte(uint3);
+short3 __ovld __cnfn convert_short3_sat_rte(uint3);
+short3 __ovld __cnfn convert_short3_rtz(uint3);
+short3 __ovld __cnfn convert_short3_sat_rtz(uint3);
+short3 __ovld __cnfn convert_short3_rtp(uint3);
+short3 __ovld __cnfn convert_short3_sat_rtp(uint3);
+short3 __ovld __cnfn convert_short3_rtn(uint3);
+short3 __ovld __cnfn convert_short3_sat_rtn(uint3);
+short3 __ovld __cnfn convert_short3(uint3);
+short3 __ovld __cnfn convert_short3_sat(uint3);
+short3 __ovld __cnfn convert_short3_rte(long3);
+short3 __ovld __cnfn convert_short3_sat_rte(long3);
+short3 __ovld __cnfn convert_short3_rtz(long3);
+short3 __ovld __cnfn convert_short3_sat_rtz(long3);
+short3 __ovld __cnfn convert_short3_rtp(long3);
+short3 __ovld __cnfn convert_short3_sat_rtp(long3);
+short3 __ovld __cnfn convert_short3_rtn(long3);
+short3 __ovld __cnfn convert_short3_sat_rtn(long3);
+short3 __ovld __cnfn convert_short3(long3);
+short3 __ovld __cnfn convert_short3_sat(long3);
+short3 __ovld __cnfn convert_short3_rte(ulong3);
+short3 __ovld __cnfn convert_short3_sat_rte(ulong3);
+short3 __ovld __cnfn convert_short3_rtz(ulong3);
+short3 __ovld __cnfn convert_short3_sat_rtz(ulong3);
+short3 __ovld __cnfn convert_short3_rtp(ulong3);
+short3 __ovld __cnfn convert_short3_sat_rtp(ulong3);
+short3 __ovld __cnfn convert_short3_rtn(ulong3);
+short3 __ovld __cnfn convert_short3_sat_rtn(ulong3);
+short3 __ovld __cnfn convert_short3(ulong3);
+short3 __ovld __cnfn convert_short3_sat(ulong3);
+short3 __ovld __cnfn convert_short3_rte(float3);
+short3 __ovld __cnfn convert_short3_sat_rte(float3);
+short3 __ovld __cnfn convert_short3_rtz(float3);
+short3 __ovld __cnfn convert_short3_sat_rtz(float3);
+short3 __ovld __cnfn convert_short3_rtp(float3);
+short3 __ovld __cnfn convert_short3_sat_rtp(float3);
+short3 __ovld __cnfn convert_short3_rtn(float3);
+short3 __ovld __cnfn convert_short3_sat_rtn(float3);
+short3 __ovld __cnfn convert_short3(float3);
+short3 __ovld __cnfn convert_short3_sat(float3);
+ushort3 __ovld __cnfn convert_ushort3_rte(char3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(char3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(char3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(char3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(char3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(char3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(char3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(char3);
+ushort3 __ovld __cnfn convert_ushort3(char3);
+ushort3 __ovld __cnfn convert_ushort3_sat(char3);
+ushort3 __ovld __cnfn convert_ushort3_rte(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(uchar3);
+ushort3 __ovld __cnfn convert_ushort3(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_sat(uchar3);
+ushort3 __ovld __cnfn convert_ushort3_rte(short3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(short3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(short3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(short3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(short3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(short3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(short3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(short3);
+ushort3 __ovld __cnfn convert_ushort3(short3);
+ushort3 __ovld __cnfn convert_ushort3_sat(short3);
+ushort3 __ovld __cnfn convert_ushort3_rte(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(ushort3);
+ushort3 __ovld __cnfn convert_ushort3(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_sat(ushort3);
+ushort3 __ovld __cnfn convert_ushort3_rte(int3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(int3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(int3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(int3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(int3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(int3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(int3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(int3);
+ushort3 __ovld __cnfn convert_ushort3(int3);
+ushort3 __ovld __cnfn convert_ushort3_sat(int3);
+ushort3 __ovld __cnfn convert_ushort3_rte(uint3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(uint3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(uint3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(uint3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(uint3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(uint3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(uint3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(uint3);
+ushort3 __ovld __cnfn convert_ushort3(uint3);
+ushort3 __ovld __cnfn convert_ushort3_sat(uint3);
+ushort3 __ovld __cnfn convert_ushort3_rte(long3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(long3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(long3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(long3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(long3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(long3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(long3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(long3);
+ushort3 __ovld __cnfn convert_ushort3(long3);
+ushort3 __ovld __cnfn convert_ushort3_sat(long3);
+ushort3 __ovld __cnfn convert_ushort3_rte(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(ulong3);
+ushort3 __ovld __cnfn convert_ushort3(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_sat(ulong3);
+ushort3 __ovld __cnfn convert_ushort3_rte(float3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(float3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(float3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(float3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(float3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(float3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(float3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(float3);
+ushort3 __ovld __cnfn convert_ushort3(float3);
+ushort3 __ovld __cnfn convert_ushort3_sat(float3);
+int3 __ovld __cnfn convert_int3_rte(char3);
+int3 __ovld __cnfn convert_int3_sat_rte(char3);
+int3 __ovld __cnfn convert_int3_rtz(char3);
+int3 __ovld __cnfn convert_int3_sat_rtz(char3);
+int3 __ovld __cnfn convert_int3_rtp(char3);
+int3 __ovld __cnfn convert_int3_sat_rtp(char3);
+int3 __ovld __cnfn convert_int3_rtn(char3);
+int3 __ovld __cnfn convert_int3_sat_rtn(char3);
+int3 __ovld __cnfn convert_int3(char3);
+int3 __ovld __cnfn convert_int3_sat(char3);
+int3 __ovld __cnfn convert_int3_rte(uchar3);
+int3 __ovld __cnfn convert_int3_sat_rte(uchar3);
+int3 __ovld __cnfn convert_int3_rtz(uchar3);
+int3 __ovld __cnfn convert_int3_sat_rtz(uchar3);
+int3 __ovld __cnfn convert_int3_rtp(uchar3);
+int3 __ovld __cnfn convert_int3_sat_rtp(uchar3);
+int3 __ovld __cnfn convert_int3_rtn(uchar3);
+int3 __ovld __cnfn convert_int3_sat_rtn(uchar3);
+int3 __ovld __cnfn convert_int3(uchar3);
+int3 __ovld __cnfn convert_int3_sat(uchar3);
+int3 __ovld __cnfn convert_int3_rte(short3);
+int3 __ovld __cnfn convert_int3_sat_rte(short3);
+int3 __ovld __cnfn convert_int3_rtz(short3);
+int3 __ovld __cnfn convert_int3_sat_rtz(short3);
+int3 __ovld __cnfn convert_int3_rtp(short3);
+int3 __ovld __cnfn convert_int3_sat_rtp(short3);
+int3 __ovld __cnfn convert_int3_rtn(short3);
+int3 __ovld __cnfn convert_int3_sat_rtn(short3);
+int3 __ovld __cnfn convert_int3(short3);
+int3 __ovld __cnfn convert_int3_sat(short3);
+int3 __ovld __cnfn convert_int3_rte(ushort3);
+int3 __ovld __cnfn convert_int3_sat_rte(ushort3);
+int3 __ovld __cnfn convert_int3_rtz(ushort3);
+int3 __ovld __cnfn convert_int3_sat_rtz(ushort3);
+int3 __ovld __cnfn convert_int3_rtp(ushort3);
+int3 __ovld __cnfn convert_int3_sat_rtp(ushort3);
+int3 __ovld __cnfn convert_int3_rtn(ushort3);
+int3 __ovld __cnfn convert_int3_sat_rtn(ushort3);
+int3 __ovld __cnfn convert_int3(ushort3);
+int3 __ovld __cnfn convert_int3_sat(ushort3);
+int3 __ovld __cnfn convert_int3_rte(int3);
+int3 __ovld __cnfn convert_int3_sat_rte(int3);
+int3 __ovld __cnfn convert_int3_rtz(int3);
+int3 __ovld __cnfn convert_int3_sat_rtz(int3);
+int3 __ovld __cnfn convert_int3_rtp(int3);
+int3 __ovld __cnfn convert_int3_sat_rtp(int3);
+int3 __ovld __cnfn convert_int3_rtn(int3);
+int3 __ovld __cnfn convert_int3_sat_rtn(int3);
+int3 __ovld __cnfn convert_int3(int3);
+int3 __ovld __cnfn convert_int3_sat(int3);
+int3 __ovld __cnfn convert_int3_rte(uint3);
+int3 __ovld __cnfn convert_int3_sat_rte(uint3);
+int3 __ovld __cnfn convert_int3_rtz(uint3);
+int3 __ovld __cnfn convert_int3_sat_rtz(uint3);
+int3 __ovld __cnfn convert_int3_rtp(uint3);
+int3 __ovld __cnfn convert_int3_sat_rtp(uint3);
+int3 __ovld __cnfn convert_int3_rtn(uint3);
+int3 __ovld __cnfn convert_int3_sat_rtn(uint3);
+int3 __ovld __cnfn convert_int3(uint3);
+int3 __ovld __cnfn convert_int3_sat(uint3);
+int3 __ovld __cnfn convert_int3_rte(long3);
+int3 __ovld __cnfn convert_int3_sat_rte(long3);
+int3 __ovld __cnfn convert_int3_rtz(long3);
+int3 __ovld __cnfn convert_int3_sat_rtz(long3);
+int3 __ovld __cnfn convert_int3_rtp(long3);
+int3 __ovld __cnfn convert_int3_sat_rtp(long3);
+int3 __ovld __cnfn convert_int3_rtn(long3);
+int3 __ovld __cnfn convert_int3_sat_rtn(long3);
+int3 __ovld __cnfn convert_int3(long3);
+int3 __ovld __cnfn convert_int3_sat(long3);
+int3 __ovld __cnfn convert_int3_rte(ulong3);
+int3 __ovld __cnfn convert_int3_sat_rte(ulong3);
+int3 __ovld __cnfn convert_int3_rtz(ulong3);
+int3 __ovld __cnfn convert_int3_sat_rtz(ulong3);
+int3 __ovld __cnfn convert_int3_rtp(ulong3);
+int3 __ovld __cnfn convert_int3_sat_rtp(ulong3);
+int3 __ovld __cnfn convert_int3_rtn(ulong3);
+int3 __ovld __cnfn convert_int3_sat_rtn(ulong3);
+int3 __ovld __cnfn convert_int3(ulong3);
+int3 __ovld __cnfn convert_int3_sat(ulong3);
+int3 __ovld __cnfn convert_int3_rte(float3);
+int3 __ovld __cnfn convert_int3_sat_rte(float3);
+int3 __ovld __cnfn convert_int3_rtz(float3);
+int3 __ovld __cnfn convert_int3_sat_rtz(float3);
+int3 __ovld __cnfn convert_int3_rtp(float3);
+int3 __ovld __cnfn convert_int3_sat_rtp(float3);
+int3 __ovld __cnfn convert_int3_rtn(float3);
+int3 __ovld __cnfn convert_int3_sat_rtn(float3);
+int3 __ovld __cnfn convert_int3(float3);
+int3 __ovld __cnfn convert_int3_sat(float3);
+uint3 __ovld __cnfn convert_uint3_rte(char3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(char3);
+uint3 __ovld __cnfn convert_uint3_rtz(char3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(char3);
+uint3 __ovld __cnfn convert_uint3_rtp(char3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(char3);
+uint3 __ovld __cnfn convert_uint3_rtn(char3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(char3);
+uint3 __ovld __cnfn convert_uint3(char3);
+uint3 __ovld __cnfn convert_uint3_sat(char3);
+uint3 __ovld __cnfn convert_uint3_rte(uchar3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(uchar3);
+uint3 __ovld __cnfn convert_uint3_rtz(uchar3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(uchar3);
+uint3 __ovld __cnfn convert_uint3_rtp(uchar3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(uchar3);
+uint3 __ovld __cnfn convert_uint3_rtn(uchar3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(uchar3);
+uint3 __ovld __cnfn convert_uint3(uchar3);
+uint3 __ovld __cnfn convert_uint3_sat(uchar3);
+uint3 __ovld __cnfn convert_uint3_rte(short3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(short3);
+uint3 __ovld __cnfn convert_uint3_rtz(short3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(short3);
+uint3 __ovld __cnfn convert_uint3_rtp(short3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(short3);
+uint3 __ovld __cnfn convert_uint3_rtn(short3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(short3);
+uint3 __ovld __cnfn convert_uint3(short3);
+uint3 __ovld __cnfn convert_uint3_sat(short3);
+uint3 __ovld __cnfn convert_uint3_rte(ushort3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(ushort3);
+uint3 __ovld __cnfn convert_uint3_rtz(ushort3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(ushort3);
+uint3 __ovld __cnfn convert_uint3_rtp(ushort3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(ushort3);
+uint3 __ovld __cnfn convert_uint3_rtn(ushort3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(ushort3);
+uint3 __ovld __cnfn convert_uint3(ushort3);
+uint3 __ovld __cnfn convert_uint3_sat(ushort3);
+uint3 __ovld __cnfn convert_uint3_rte(int3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(int3);
+uint3 __ovld __cnfn convert_uint3_rtz(int3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(int3);
+uint3 __ovld __cnfn convert_uint3_rtp(int3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(int3);
+uint3 __ovld __cnfn convert_uint3_rtn(int3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(int3);
+uint3 __ovld __cnfn convert_uint3(int3);
+uint3 __ovld __cnfn convert_uint3_sat(int3);
+uint3 __ovld __cnfn convert_uint3_rte(uint3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(uint3);
+uint3 __ovld __cnfn convert_uint3_rtz(uint3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(uint3);
+uint3 __ovld __cnfn convert_uint3_rtp(uint3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(uint3);
+uint3 __ovld __cnfn convert_uint3_rtn(uint3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(uint3);
+uint3 __ovld __cnfn convert_uint3(uint3);
+uint3 __ovld __cnfn convert_uint3_sat(uint3);
+uint3 __ovld __cnfn convert_uint3_rte(long3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(long3);
+uint3 __ovld __cnfn convert_uint3_rtz(long3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(long3);
+uint3 __ovld __cnfn convert_uint3_rtp(long3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(long3);
+uint3 __ovld __cnfn convert_uint3_rtn(long3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(long3);
+uint3 __ovld __cnfn convert_uint3(long3);
+uint3 __ovld __cnfn convert_uint3_sat(long3);
+uint3 __ovld __cnfn convert_uint3_rte(ulong3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(ulong3);
+uint3 __ovld __cnfn convert_uint3_rtz(ulong3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(ulong3);
+uint3 __ovld __cnfn convert_uint3_rtp(ulong3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(ulong3);
+uint3 __ovld __cnfn convert_uint3_rtn(ulong3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(ulong3);
+uint3 __ovld __cnfn convert_uint3(ulong3);
+uint3 __ovld __cnfn convert_uint3_sat(ulong3);
+uint3 __ovld __cnfn convert_uint3_rte(float3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(float3);
+uint3 __ovld __cnfn convert_uint3_rtz(float3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(float3);
+uint3 __ovld __cnfn convert_uint3_rtp(float3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(float3);
+uint3 __ovld __cnfn convert_uint3_rtn(float3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(float3);
+uint3 __ovld __cnfn convert_uint3(float3);
+uint3 __ovld __cnfn convert_uint3_sat(float3);
+long3 __ovld __cnfn convert_long3_rte(char3);
+long3 __ovld __cnfn convert_long3_sat_rte(char3);
+long3 __ovld __cnfn convert_long3_rtz(char3);
+long3 __ovld __cnfn convert_long3_sat_rtz(char3);
+long3 __ovld __cnfn convert_long3_rtp(char3);
+long3 __ovld __cnfn convert_long3_sat_rtp(char3);
+long3 __ovld __cnfn convert_long3_rtn(char3);
+long3 __ovld __cnfn convert_long3_sat_rtn(char3);
+long3 __ovld __cnfn convert_long3(char3);
+long3 __ovld __cnfn convert_long3_sat(char3);
+long3 __ovld __cnfn convert_long3_rte(uchar3);
+long3 __ovld __cnfn convert_long3_sat_rte(uchar3);
+long3 __ovld __cnfn convert_long3_rtz(uchar3);
+long3 __ovld __cnfn convert_long3_sat_rtz(uchar3);
+long3 __ovld __cnfn convert_long3_rtp(uchar3);
+long3 __ovld __cnfn convert_long3_sat_rtp(uchar3);
+long3 __ovld __cnfn convert_long3_rtn(uchar3);
+long3 __ovld __cnfn convert_long3_sat_rtn(uchar3);
+long3 __ovld __cnfn convert_long3(uchar3);
+long3 __ovld __cnfn convert_long3_sat(uchar3);
+long3 __ovld __cnfn convert_long3_rte(short3);
+long3 __ovld __cnfn convert_long3_sat_rte(short3);
+long3 __ovld __cnfn convert_long3_rtz(short3);
+long3 __ovld __cnfn convert_long3_sat_rtz(short3);
+long3 __ovld __cnfn convert_long3_rtp(short3);
+long3 __ovld __cnfn convert_long3_sat_rtp(short3);
+long3 __ovld __cnfn convert_long3_rtn(short3);
+long3 __ovld __cnfn convert_long3_sat_rtn(short3);
+long3 __ovld __cnfn convert_long3(short3);
+long3 __ovld __cnfn convert_long3_sat(short3);
+long3 __ovld __cnfn convert_long3_rte(ushort3);
+long3 __ovld __cnfn convert_long3_sat_rte(ushort3);
+long3 __ovld __cnfn convert_long3_rtz(ushort3);
+long3 __ovld __cnfn convert_long3_sat_rtz(ushort3);
+long3 __ovld __cnfn convert_long3_rtp(ushort3);
+long3 __ovld __cnfn convert_long3_sat_rtp(ushort3);
+long3 __ovld __cnfn convert_long3_rtn(ushort3);
+long3 __ovld __cnfn convert_long3_sat_rtn(ushort3);
+long3 __ovld __cnfn convert_long3(ushort3);
+long3 __ovld __cnfn convert_long3_sat(ushort3);
+long3 __ovld __cnfn convert_long3_rte(int3);
+long3 __ovld __cnfn convert_long3_sat_rte(int3);
+long3 __ovld __cnfn convert_long3_rtz(int3);
+long3 __ovld __cnfn convert_long3_sat_rtz(int3);
+long3 __ovld __cnfn convert_long3_rtp(int3);
+long3 __ovld __cnfn convert_long3_sat_rtp(int3);
+long3 __ovld __cnfn convert_long3_rtn(int3);
+long3 __ovld __cnfn convert_long3_sat_rtn(int3);
+long3 __ovld __cnfn convert_long3(int3);
+long3 __ovld __cnfn convert_long3_sat(int3);
+long3 __ovld __cnfn convert_long3_rte(uint3);
+long3 __ovld __cnfn convert_long3_sat_rte(uint3);
+long3 __ovld __cnfn convert_long3_rtz(uint3);
+long3 __ovld __cnfn convert_long3_sat_rtz(uint3);
+long3 __ovld __cnfn convert_long3_rtp(uint3);
+long3 __ovld __cnfn convert_long3_sat_rtp(uint3);
+long3 __ovld __cnfn convert_long3_rtn(uint3);
+long3 __ovld __cnfn convert_long3_sat_rtn(uint3);
+long3 __ovld __cnfn convert_long3(uint3);
+long3 __ovld __cnfn convert_long3_sat(uint3);
+long3 __ovld __cnfn convert_long3_rte(long3);
+long3 __ovld __cnfn convert_long3_sat_rte(long3);
+long3 __ovld __cnfn convert_long3_rtz(long3);
+long3 __ovld __cnfn convert_long3_sat_rtz(long3);
+long3 __ovld __cnfn convert_long3_rtp(long3);
+long3 __ovld __cnfn convert_long3_sat_rtp(long3);
+long3 __ovld __cnfn convert_long3_rtn(long3);
+long3 __ovld __cnfn convert_long3_sat_rtn(long3);
+long3 __ovld __cnfn convert_long3(long3);
+long3 __ovld __cnfn convert_long3_sat(long3);
+long3 __ovld __cnfn convert_long3_rte(ulong3);
+long3 __ovld __cnfn convert_long3_sat_rte(ulong3);
+long3 __ovld __cnfn convert_long3_rtz(ulong3);
+long3 __ovld __cnfn convert_long3_sat_rtz(ulong3);
+long3 __ovld __cnfn convert_long3_rtp(ulong3);
+long3 __ovld __cnfn convert_long3_sat_rtp(ulong3);
+long3 __ovld __cnfn convert_long3_rtn(ulong3);
+long3 __ovld __cnfn convert_long3_sat_rtn(ulong3);
+long3 __ovld __cnfn convert_long3(ulong3);
+long3 __ovld __cnfn convert_long3_sat(ulong3);
+long3 __ovld __cnfn convert_long3_rte(float3);
+long3 __ovld __cnfn convert_long3_sat_rte(float3);
+long3 __ovld __cnfn convert_long3_rtz(float3);
+long3 __ovld __cnfn convert_long3_sat_rtz(float3);
+long3 __ovld __cnfn convert_long3_rtp(float3);
+long3 __ovld __cnfn convert_long3_sat_rtp(float3);
+long3 __ovld __cnfn convert_long3_rtn(float3);
+long3 __ovld __cnfn convert_long3_sat_rtn(float3);
+long3 __ovld __cnfn convert_long3(float3);
+long3 __ovld __cnfn convert_long3_sat(float3);
+ulong3 __ovld __cnfn convert_ulong3_rte(char3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(char3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(char3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(char3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(char3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(char3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(char3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(char3);
+ulong3 __ovld __cnfn convert_ulong3(char3);
+ulong3 __ovld __cnfn convert_ulong3_sat(char3);
+ulong3 __ovld __cnfn convert_ulong3_rte(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(uchar3);
+ulong3 __ovld __cnfn convert_ulong3(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_sat(uchar3);
+ulong3 __ovld __cnfn convert_ulong3_rte(short3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(short3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(short3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(short3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(short3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(short3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(short3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(short3);
+ulong3 __ovld __cnfn convert_ulong3(short3);
+ulong3 __ovld __cnfn convert_ulong3_sat(short3);
+ulong3 __ovld __cnfn convert_ulong3_rte(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(ushort3);
+ulong3 __ovld __cnfn convert_ulong3(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_sat(ushort3);
+ulong3 __ovld __cnfn convert_ulong3_rte(int3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(int3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(int3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(int3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(int3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(int3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(int3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(int3);
+ulong3 __ovld __cnfn convert_ulong3(int3);
+ulong3 __ovld __cnfn convert_ulong3_sat(int3);
+ulong3 __ovld __cnfn convert_ulong3_rte(uint3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(uint3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(uint3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(uint3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(uint3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(uint3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(uint3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(uint3);
+ulong3 __ovld __cnfn convert_ulong3(uint3);
+ulong3 __ovld __cnfn convert_ulong3_sat(uint3);
+ulong3 __ovld __cnfn convert_ulong3_rte(long3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(long3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(long3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(long3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(long3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(long3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(long3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(long3);
+ulong3 __ovld __cnfn convert_ulong3(long3);
+ulong3 __ovld __cnfn convert_ulong3_sat(long3);
+ulong3 __ovld __cnfn convert_ulong3_rte(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(ulong3);
+ulong3 __ovld __cnfn convert_ulong3(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_sat(ulong3);
+ulong3 __ovld __cnfn convert_ulong3_rte(float3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(float3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(float3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(float3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(float3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(float3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(float3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(float3);
+ulong3 __ovld __cnfn convert_ulong3(float3);
+ulong3 __ovld __cnfn convert_ulong3_sat(float3);
+float3 __ovld __cnfn convert_float3_rte(char3);
+float3 __ovld __cnfn convert_float3_rtz(char3);
+float3 __ovld __cnfn convert_float3_rtp(char3);
+float3 __ovld __cnfn convert_float3_rtn(char3);
+float3 __ovld __cnfn convert_float3(char3);
+float3 __ovld __cnfn convert_float3_rte(uchar3);
+float3 __ovld __cnfn convert_float3_rtz(uchar3);
+float3 __ovld __cnfn convert_float3_rtp(uchar3);
+float3 __ovld __cnfn convert_float3_rtn(uchar3);
+float3 __ovld __cnfn convert_float3(uchar3);
+float3 __ovld __cnfn convert_float3_rte(short3);
+float3 __ovld __cnfn convert_float3_rtz(short3);
+float3 __ovld __cnfn convert_float3_rtp(short3);
+float3 __ovld __cnfn convert_float3_rtn(short3);
+float3 __ovld __cnfn convert_float3(short3);
+float3 __ovld __cnfn convert_float3_rte(ushort3);
+float3 __ovld __cnfn convert_float3_rtz(ushort3);
+float3 __ovld __cnfn convert_float3_rtp(ushort3);
+float3 __ovld __cnfn convert_float3_rtn(ushort3);
+float3 __ovld __cnfn convert_float3(ushort3);
+float3 __ovld __cnfn convert_float3_rte(int3);
+float3 __ovld __cnfn convert_float3_rtz(int3);
+float3 __ovld __cnfn convert_float3_rtp(int3);
+float3 __ovld __cnfn convert_float3_rtn(int3);
+float3 __ovld __cnfn convert_float3(int3);
+float3 __ovld __cnfn convert_float3_rte(uint3);
+float3 __ovld __cnfn convert_float3_rtz(uint3);
+float3 __ovld __cnfn convert_float3_rtp(uint3);
+float3 __ovld __cnfn convert_float3_rtn(uint3);
+float3 __ovld __cnfn convert_float3(uint3);
+float3 __ovld __cnfn convert_float3_rte(long3);
+float3 __ovld __cnfn convert_float3_rtz(long3);
+float3 __ovld __cnfn convert_float3_rtp(long3);
+float3 __ovld __cnfn convert_float3_rtn(long3);
+float3 __ovld __cnfn convert_float3(long3);
+float3 __ovld __cnfn convert_float3_rte(ulong3);
+float3 __ovld __cnfn convert_float3_rtz(ulong3);
+float3 __ovld __cnfn convert_float3_rtp(ulong3);
+float3 __ovld __cnfn convert_float3_rtn(ulong3);
+float3 __ovld __cnfn convert_float3(ulong3);
+float3 __ovld __cnfn convert_float3_rte(float3);
+float3 __ovld __cnfn convert_float3_rtz(float3);
+float3 __ovld __cnfn convert_float3_rtp(float3);
+float3 __ovld __cnfn convert_float3_rtn(float3);
+float3 __ovld __cnfn convert_float3(float3);
+char4 __ovld __cnfn convert_char4_rte(char4);
+char4 __ovld __cnfn convert_char4_sat_rte(char4);
+char4 __ovld __cnfn convert_char4_rtz(char4);
+char4 __ovld __cnfn convert_char4_sat_rtz(char4);
+char4 __ovld __cnfn convert_char4_rtp(char4);
+char4 __ovld __cnfn convert_char4_sat_rtp(char4);
+char4 __ovld __cnfn convert_char4_rtn(char4);
+char4 __ovld __cnfn convert_char4_sat_rtn(char4);
+char4 __ovld __cnfn convert_char4(char4);
+char4 __ovld __cnfn convert_char4_sat(char4);
+char4 __ovld __cnfn convert_char4_rte(uchar4);
+char4 __ovld __cnfn convert_char4_sat_rte(uchar4);
+char4 __ovld __cnfn convert_char4_rtz(uchar4);
+char4 __ovld __cnfn convert_char4_sat_rtz(uchar4);
+char4 __ovld __cnfn convert_char4_rtp(uchar4);
+char4 __ovld __cnfn convert_char4_sat_rtp(uchar4);
+char4 __ovld __cnfn convert_char4_rtn(uchar4);
+char4 __ovld __cnfn convert_char4_sat_rtn(uchar4);
+char4 __ovld __cnfn convert_char4(uchar4);
+char4 __ovld __cnfn convert_char4_sat(uchar4);
+char4 __ovld __cnfn convert_char4_rte(short4);
+char4 __ovld __cnfn convert_char4_sat_rte(short4);
+char4 __ovld __cnfn convert_char4_rtz(short4);
+char4 __ovld __cnfn convert_char4_sat_rtz(short4);
+char4 __ovld __cnfn convert_char4_rtp(short4);
+char4 __ovld __cnfn convert_char4_sat_rtp(short4);
+char4 __ovld __cnfn convert_char4_rtn(short4);
+char4 __ovld __cnfn convert_char4_sat_rtn(short4);
+char4 __ovld __cnfn convert_char4(short4);
+char4 __ovld __cnfn convert_char4_sat(short4);
+char4 __ovld __cnfn convert_char4_rte(ushort4);
+char4 __ovld __cnfn convert_char4_sat_rte(ushort4);
+char4 __ovld __cnfn convert_char4_rtz(ushort4);
+char4 __ovld __cnfn convert_char4_sat_rtz(ushort4);
+char4 __ovld __cnfn convert_char4_rtp(ushort4);
+char4 __ovld __cnfn convert_char4_sat_rtp(ushort4);
+char4 __ovld __cnfn convert_char4_rtn(ushort4);
+char4 __ovld __cnfn convert_char4_sat_rtn(ushort4);
+char4 __ovld __cnfn convert_char4(ushort4);
+char4 __ovld __cnfn convert_char4_sat(ushort4);
+char4 __ovld __cnfn convert_char4_rte(int4);
+char4 __ovld __cnfn convert_char4_sat_rte(int4);
+char4 __ovld __cnfn convert_char4_rtz(int4);
+char4 __ovld __cnfn convert_char4_sat_rtz(int4);
+char4 __ovld __cnfn convert_char4_rtp(int4);
+char4 __ovld __cnfn convert_char4_sat_rtp(int4);
+char4 __ovld __cnfn convert_char4_rtn(int4);
+char4 __ovld __cnfn convert_char4_sat_rtn(int4);
+char4 __ovld __cnfn convert_char4(int4);
+char4 __ovld __cnfn convert_char4_sat(int4);
+char4 __ovld __cnfn convert_char4_rte(uint4);
+char4 __ovld __cnfn convert_char4_sat_rte(uint4);
+char4 __ovld __cnfn convert_char4_rtz(uint4);
+char4 __ovld __cnfn convert_char4_sat_rtz(uint4);
+char4 __ovld __cnfn convert_char4_rtp(uint4);
+char4 __ovld __cnfn convert_char4_sat_rtp(uint4);
+char4 __ovld __cnfn convert_char4_rtn(uint4);
+char4 __ovld __cnfn convert_char4_sat_rtn(uint4);
+char4 __ovld __cnfn convert_char4(uint4);
+char4 __ovld __cnfn convert_char4_sat(uint4);
+char4 __ovld __cnfn convert_char4_rte(long4);
+char4 __ovld __cnfn convert_char4_sat_rte(long4);
+char4 __ovld __cnfn convert_char4_rtz(long4);
+char4 __ovld __cnfn convert_char4_sat_rtz(long4);
+char4 __ovld __cnfn convert_char4_rtp(long4);
+char4 __ovld __cnfn convert_char4_sat_rtp(long4);
+char4 __ovld __cnfn convert_char4_rtn(long4);
+char4 __ovld __cnfn convert_char4_sat_rtn(long4);
+char4 __ovld __cnfn convert_char4(long4);
+char4 __ovld __cnfn convert_char4_sat(long4);
+char4 __ovld __cnfn convert_char4_rte(ulong4);
+char4 __ovld __cnfn convert_char4_sat_rte(ulong4);
+char4 __ovld __cnfn convert_char4_rtz(ulong4);
+char4 __ovld __cnfn convert_char4_sat_rtz(ulong4);
+char4 __ovld __cnfn convert_char4_rtp(ulong4);
+char4 __ovld __cnfn convert_char4_sat_rtp(ulong4);
+char4 __ovld __cnfn convert_char4_rtn(ulong4);
+char4 __ovld __cnfn convert_char4_sat_rtn(ulong4);
+char4 __ovld __cnfn convert_char4(ulong4);
+char4 __ovld __cnfn convert_char4_sat(ulong4);
+char4 __ovld __cnfn convert_char4_rte(float4);
+char4 __ovld __cnfn convert_char4_sat_rte(float4);
+char4 __ovld __cnfn convert_char4_rtz(float4);
+char4 __ovld __cnfn convert_char4_sat_rtz(float4);
+char4 __ovld __cnfn convert_char4_rtp(float4);
+char4 __ovld __cnfn convert_char4_sat_rtp(float4);
+char4 __ovld __cnfn convert_char4_rtn(float4);
+char4 __ovld __cnfn convert_char4_sat_rtn(float4);
+char4 __ovld __cnfn convert_char4(float4);
+char4 __ovld __cnfn convert_char4_sat(float4);
+uchar4 __ovld __cnfn convert_uchar4_rte(char4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(char4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(char4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(char4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(char4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(char4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(char4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(char4);
+uchar4 __ovld __cnfn convert_uchar4(char4);
+uchar4 __ovld __cnfn convert_uchar4_sat(char4);
+uchar4 __ovld __cnfn convert_uchar4_rte(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(uchar4);
+uchar4 __ovld __cnfn convert_uchar4(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_sat(uchar4);
+uchar4 __ovld __cnfn convert_uchar4_rte(short4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(short4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(short4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(short4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(short4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(short4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(short4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(short4);
+uchar4 __ovld __cnfn convert_uchar4(short4);
+uchar4 __ovld __cnfn convert_uchar4_sat(short4);
+uchar4 __ovld __cnfn convert_uchar4_rte(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(ushort4);
+uchar4 __ovld __cnfn convert_uchar4(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_sat(ushort4);
+uchar4 __ovld __cnfn convert_uchar4_rte(int4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(int4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(int4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(int4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(int4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(int4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(int4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(int4);
+uchar4 __ovld __cnfn convert_uchar4(int4);
+uchar4 __ovld __cnfn convert_uchar4_sat(int4);
+uchar4 __ovld __cnfn convert_uchar4_rte(uint4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(uint4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(uint4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(uint4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(uint4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(uint4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(uint4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(uint4);
+uchar4 __ovld __cnfn convert_uchar4(uint4);
+uchar4 __ovld __cnfn convert_uchar4_sat(uint4);
+uchar4 __ovld __cnfn convert_uchar4_rte(long4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(long4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(long4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(long4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(long4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(long4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(long4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(long4);
+uchar4 __ovld __cnfn convert_uchar4(long4);
+uchar4 __ovld __cnfn convert_uchar4_sat(long4);
+uchar4 __ovld __cnfn convert_uchar4_rte(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(ulong4);
+uchar4 __ovld __cnfn convert_uchar4(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_sat(ulong4);
+uchar4 __ovld __cnfn convert_uchar4_rte(float4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(float4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(float4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(float4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(float4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(float4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(float4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(float4);
+uchar4 __ovld __cnfn convert_uchar4(float4);
+uchar4 __ovld __cnfn convert_uchar4_sat(float4);
+short4 __ovld __cnfn convert_short4_rte(char4);
+short4 __ovld __cnfn convert_short4_sat_rte(char4);
+short4 __ovld __cnfn convert_short4_rtz(char4);
+short4 __ovld __cnfn convert_short4_sat_rtz(char4);
+short4 __ovld __cnfn convert_short4_rtp(char4);
+short4 __ovld __cnfn convert_short4_sat_rtp(char4);
+short4 __ovld __cnfn convert_short4_rtn(char4);
+short4 __ovld __cnfn convert_short4_sat_rtn(char4);
+short4 __ovld __cnfn convert_short4(char4);
+short4 __ovld __cnfn convert_short4_sat(char4);
+short4 __ovld __cnfn convert_short4_rte(uchar4);
+short4 __ovld __cnfn convert_short4_sat_rte(uchar4);
+short4 __ovld __cnfn convert_short4_rtz(uchar4);
+short4 __ovld __cnfn convert_short4_sat_rtz(uchar4);
+short4 __ovld __cnfn convert_short4_rtp(uchar4);
+short4 __ovld __cnfn convert_short4_sat_rtp(uchar4);
+short4 __ovld __cnfn convert_short4_rtn(uchar4);
+short4 __ovld __cnfn convert_short4_sat_rtn(uchar4);
+short4 __ovld __cnfn convert_short4(uchar4);
+short4 __ovld __cnfn convert_short4_sat(uchar4);
+short4 __ovld __cnfn convert_short4_rte(short4);
+short4 __ovld __cnfn convert_short4_sat_rte(short4);
+short4 __ovld __cnfn convert_short4_rtz(short4);
+short4 __ovld __cnfn convert_short4_sat_rtz(short4);
+short4 __ovld __cnfn convert_short4_rtp(short4);
+short4 __ovld __cnfn convert_short4_sat_rtp(short4);
+short4 __ovld __cnfn convert_short4_rtn(short4);
+short4 __ovld __cnfn convert_short4_sat_rtn(short4);
+short4 __ovld __cnfn convert_short4(short4);
+short4 __ovld __cnfn convert_short4_sat(short4);
+short4 __ovld __cnfn convert_short4_rte(ushort4);
+short4 __ovld __cnfn convert_short4_sat_rte(ushort4);
+short4 __ovld __cnfn convert_short4_rtz(ushort4);
+short4 __ovld __cnfn convert_short4_sat_rtz(ushort4);
+short4 __ovld __cnfn convert_short4_rtp(ushort4);
+short4 __ovld __cnfn convert_short4_sat_rtp(ushort4);
+short4 __ovld __cnfn convert_short4_rtn(ushort4);
+short4 __ovld __cnfn convert_short4_sat_rtn(ushort4);
+short4 __ovld __cnfn convert_short4(ushort4);
+short4 __ovld __cnfn convert_short4_sat(ushort4);
+short4 __ovld __cnfn convert_short4_rte(int4);
+short4 __ovld __cnfn convert_short4_sat_rte(int4);
+short4 __ovld __cnfn convert_short4_rtz(int4);
+short4 __ovld __cnfn convert_short4_sat_rtz(int4);
+short4 __ovld __cnfn convert_short4_rtp(int4);
+short4 __ovld __cnfn convert_short4_sat_rtp(int4);
+short4 __ovld __cnfn convert_short4_rtn(int4);
+short4 __ovld __cnfn convert_short4_sat_rtn(int4);
+short4 __ovld __cnfn convert_short4(int4);
+short4 __ovld __cnfn convert_short4_sat(int4);
+short4 __ovld __cnfn convert_short4_rte(uint4);
+short4 __ovld __cnfn convert_short4_sat_rte(uint4);
+short4 __ovld __cnfn convert_short4_rtz(uint4);
+short4 __ovld __cnfn convert_short4_sat_rtz(uint4);
+short4 __ovld __cnfn convert_short4_rtp(uint4);
+short4 __ovld __cnfn convert_short4_sat_rtp(uint4);
+short4 __ovld __cnfn convert_short4_rtn(uint4);
+short4 __ovld __cnfn convert_short4_sat_rtn(uint4);
+short4 __ovld __cnfn convert_short4(uint4);
+short4 __ovld __cnfn convert_short4_sat(uint4);
+short4 __ovld __cnfn convert_short4_rte(long4);
+short4 __ovld __cnfn convert_short4_sat_rte(long4);
+short4 __ovld __cnfn convert_short4_rtz(long4);
+short4 __ovld __cnfn convert_short4_sat_rtz(long4);
+short4 __ovld __cnfn convert_short4_rtp(long4);
+short4 __ovld __cnfn convert_short4_sat_rtp(long4);
+short4 __ovld __cnfn convert_short4_rtn(long4);
+short4 __ovld __cnfn convert_short4_sat_rtn(long4);
+short4 __ovld __cnfn convert_short4(long4);
+short4 __ovld __cnfn convert_short4_sat(long4);
+short4 __ovld __cnfn convert_short4_rte(ulong4);
+short4 __ovld __cnfn convert_short4_sat_rte(ulong4);
+short4 __ovld __cnfn convert_short4_rtz(ulong4);
+short4 __ovld __cnfn convert_short4_sat_rtz(ulong4);
+short4 __ovld __cnfn convert_short4_rtp(ulong4);
+short4 __ovld __cnfn convert_short4_sat_rtp(ulong4);
+short4 __ovld __cnfn convert_short4_rtn(ulong4);
+short4 __ovld __cnfn convert_short4_sat_rtn(ulong4);
+short4 __ovld __cnfn convert_short4(ulong4);
+short4 __ovld __cnfn convert_short4_sat(ulong4);
+short4 __ovld __cnfn convert_short4_rte(float4);
+short4 __ovld __cnfn convert_short4_sat_rte(float4);
+short4 __ovld __cnfn convert_short4_rtz(float4);
+short4 __ovld __cnfn convert_short4_sat_rtz(float4);
+short4 __ovld __cnfn convert_short4_rtp(float4);
+short4 __ovld __cnfn convert_short4_sat_rtp(float4);
+short4 __ovld __cnfn convert_short4_rtn(float4);
+short4 __ovld __cnfn convert_short4_sat_rtn(float4);
+short4 __ovld __cnfn convert_short4(float4);
+short4 __ovld __cnfn convert_short4_sat(float4);
+ushort4 __ovld __cnfn convert_ushort4_rte(char4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(char4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(char4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(char4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(char4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(char4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(char4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(char4);
+ushort4 __ovld __cnfn convert_ushort4(char4);
+ushort4 __ovld __cnfn convert_ushort4_sat(char4);
+ushort4 __ovld __cnfn convert_ushort4_rte(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(uchar4);
+ushort4 __ovld __cnfn convert_ushort4(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_sat(uchar4);
+ushort4 __ovld __cnfn convert_ushort4_rte(short4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(short4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(short4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(short4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(short4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(short4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(short4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(short4);
+ushort4 __ovld __cnfn convert_ushort4(short4);
+ushort4 __ovld __cnfn convert_ushort4_sat(short4);
+ushort4 __ovld __cnfn convert_ushort4_rte(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(ushort4);
+ushort4 __ovld __cnfn convert_ushort4(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_sat(ushort4);
+ushort4 __ovld __cnfn convert_ushort4_rte(int4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(int4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(int4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(int4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(int4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(int4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(int4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(int4);
+ushort4 __ovld __cnfn convert_ushort4(int4);
+ushort4 __ovld __cnfn convert_ushort4_sat(int4);
+ushort4 __ovld __cnfn convert_ushort4_rte(uint4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(uint4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(uint4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(uint4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(uint4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(uint4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(uint4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(uint4);
+ushort4 __ovld __cnfn convert_ushort4(uint4);
+ushort4 __ovld __cnfn convert_ushort4_sat(uint4);
+ushort4 __ovld __cnfn convert_ushort4_rte(long4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(long4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(long4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(long4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(long4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(long4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(long4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(long4);
+ushort4 __ovld __cnfn convert_ushort4(long4);
+ushort4 __ovld __cnfn convert_ushort4_sat(long4);
+ushort4 __ovld __cnfn convert_ushort4_rte(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(ulong4);
+ushort4 __ovld __cnfn convert_ushort4(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_sat(ulong4);
+ushort4 __ovld __cnfn convert_ushort4_rte(float4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(float4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(float4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(float4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(float4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(float4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(float4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(float4);
+ushort4 __ovld __cnfn convert_ushort4(float4);
+ushort4 __ovld __cnfn convert_ushort4_sat(float4);
+int4 __ovld __cnfn convert_int4_rte(char4);
+int4 __ovld __cnfn convert_int4_sat_rte(char4);
+int4 __ovld __cnfn convert_int4_rtz(char4);
+int4 __ovld __cnfn convert_int4_sat_rtz(char4);
+int4 __ovld __cnfn convert_int4_rtp(char4);
+int4 __ovld __cnfn convert_int4_sat_rtp(char4);
+int4 __ovld __cnfn convert_int4_rtn(char4);
+int4 __ovld __cnfn convert_int4_sat_rtn(char4);
+int4 __ovld __cnfn convert_int4(char4);
+int4 __ovld __cnfn convert_int4_sat(char4);
+int4 __ovld __cnfn convert_int4_rte(uchar4);
+int4 __ovld __cnfn convert_int4_sat_rte(uchar4);
+int4 __ovld __cnfn convert_int4_rtz(uchar4);
+int4 __ovld __cnfn convert_int4_sat_rtz(uchar4);
+int4 __ovld __cnfn convert_int4_rtp(uchar4);
+int4 __ovld __cnfn convert_int4_sat_rtp(uchar4);
+int4 __ovld __cnfn convert_int4_rtn(uchar4);
+int4 __ovld __cnfn convert_int4_sat_rtn(uchar4);
+int4 __ovld __cnfn convert_int4(uchar4);
+int4 __ovld __cnfn convert_int4_sat(uchar4);
+int4 __ovld __cnfn convert_int4_rte(short4);
+int4 __ovld __cnfn convert_int4_sat_rte(short4);
+int4 __ovld __cnfn convert_int4_rtz(short4);
+int4 __ovld __cnfn convert_int4_sat_rtz(short4);
+int4 __ovld __cnfn convert_int4_rtp(short4);
+int4 __ovld __cnfn convert_int4_sat_rtp(short4);
+int4 __ovld __cnfn convert_int4_rtn(short4);
+int4 __ovld __cnfn convert_int4_sat_rtn(short4);
+int4 __ovld __cnfn convert_int4(short4);
+int4 __ovld __cnfn convert_int4_sat(short4);
+int4 __ovld __cnfn convert_int4_rte(ushort4);
+int4 __ovld __cnfn convert_int4_sat_rte(ushort4);
+int4 __ovld __cnfn convert_int4_rtz(ushort4);
+int4 __ovld __cnfn convert_int4_sat_rtz(ushort4);
+int4 __ovld __cnfn convert_int4_rtp(ushort4);
+int4 __ovld __cnfn convert_int4_sat_rtp(ushort4);
+int4 __ovld __cnfn convert_int4_rtn(ushort4);
+int4 __ovld __cnfn convert_int4_sat_rtn(ushort4);
+int4 __ovld __cnfn convert_int4(ushort4);
+int4 __ovld __cnfn convert_int4_sat(ushort4);
+int4 __ovld __cnfn convert_int4_rte(int4);
+int4 __ovld __cnfn convert_int4_sat_rte(int4);
+int4 __ovld __cnfn convert_int4_rtz(int4);
+int4 __ovld __cnfn convert_int4_sat_rtz(int4);
+int4 __ovld __cnfn convert_int4_rtp(int4);
+int4 __ovld __cnfn convert_int4_sat_rtp(int4);
+int4 __ovld __cnfn convert_int4_rtn(int4);
+int4 __ovld __cnfn convert_int4_sat_rtn(int4);
+int4 __ovld __cnfn convert_int4(int4);
+int4 __ovld __cnfn convert_int4_sat(int4);
+int4 __ovld __cnfn convert_int4_rte(uint4);
+int4 __ovld __cnfn convert_int4_sat_rte(uint4);
+int4 __ovld __cnfn convert_int4_rtz(uint4);
+int4 __ovld __cnfn convert_int4_sat_rtz(uint4);
+int4 __ovld __cnfn convert_int4_rtp(uint4);
+int4 __ovld __cnfn convert_int4_sat_rtp(uint4);
+int4 __ovld __cnfn convert_int4_rtn(uint4);
+int4 __ovld __cnfn convert_int4_sat_rtn(uint4);
+int4 __ovld __cnfn convert_int4(uint4);
+int4 __ovld __cnfn convert_int4_sat(uint4);
+int4 __ovld __cnfn convert_int4_rte(long4);
+int4 __ovld __cnfn convert_int4_sat_rte(long4);
+int4 __ovld __cnfn convert_int4_rtz(long4);
+int4 __ovld __cnfn convert_int4_sat_rtz(long4);
+int4 __ovld __cnfn convert_int4_rtp(long4);
+int4 __ovld __cnfn convert_int4_sat_rtp(long4);
+int4 __ovld __cnfn convert_int4_rtn(long4);
+int4 __ovld __cnfn convert_int4_sat_rtn(long4);
+int4 __ovld __cnfn convert_int4(long4);
+int4 __ovld __cnfn convert_int4_sat(long4);
+int4 __ovld __cnfn convert_int4_rte(ulong4);
+int4 __ovld __cnfn convert_int4_sat_rte(ulong4);
+int4 __ovld __cnfn convert_int4_rtz(ulong4);
+int4 __ovld __cnfn convert_int4_sat_rtz(ulong4);
+int4 __ovld __cnfn convert_int4_rtp(ulong4);
+int4 __ovld __cnfn convert_int4_sat_rtp(ulong4);
+int4 __ovld __cnfn convert_int4_rtn(ulong4);
+int4 __ovld __cnfn convert_int4_sat_rtn(ulong4);
+int4 __ovld __cnfn convert_int4(ulong4);
+int4 __ovld __cnfn convert_int4_sat(ulong4);
+int4 __ovld __cnfn convert_int4_rte(float4);
+int4 __ovld __cnfn convert_int4_sat_rte(float4);
+int4 __ovld __cnfn convert_int4_rtz(float4);
+int4 __ovld __cnfn convert_int4_sat_rtz(float4);
+int4 __ovld __cnfn convert_int4_rtp(float4);
+int4 __ovld __cnfn convert_int4_sat_rtp(float4);
+int4 __ovld __cnfn convert_int4_rtn(float4);
+int4 __ovld __cnfn convert_int4_sat_rtn(float4);
+int4 __ovld __cnfn convert_int4(float4);
+int4 __ovld __cnfn convert_int4_sat(float4);
+uint4 __ovld __cnfn convert_uint4_rte(char4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(char4);
+uint4 __ovld __cnfn convert_uint4_rtz(char4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(char4);
+uint4 __ovld __cnfn convert_uint4_rtp(char4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(char4);
+uint4 __ovld __cnfn convert_uint4_rtn(char4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(char4);
+uint4 __ovld __cnfn convert_uint4(char4);
+uint4 __ovld __cnfn convert_uint4_sat(char4);
+uint4 __ovld __cnfn convert_uint4_rte(uchar4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(uchar4);
+uint4 __ovld __cnfn convert_uint4_rtz(uchar4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(uchar4);
+uint4 __ovld __cnfn convert_uint4_rtp(uchar4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(uchar4);
+uint4 __ovld __cnfn convert_uint4_rtn(uchar4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(uchar4);
+uint4 __ovld __cnfn convert_uint4(uchar4);
+uint4 __ovld __cnfn convert_uint4_sat(uchar4);
+uint4 __ovld __cnfn convert_uint4_rte(short4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(short4);
+uint4 __ovld __cnfn convert_uint4_rtz(short4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(short4);
+uint4 __ovld __cnfn convert_uint4_rtp(short4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(short4);
+uint4 __ovld __cnfn convert_uint4_rtn(short4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(short4);
+uint4 __ovld __cnfn convert_uint4(short4);
+uint4 __ovld __cnfn convert_uint4_sat(short4);
+uint4 __ovld __cnfn convert_uint4_rte(ushort4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(ushort4);
+uint4 __ovld __cnfn convert_uint4_rtz(ushort4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(ushort4);
+uint4 __ovld __cnfn convert_uint4_rtp(ushort4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(ushort4);
+uint4 __ovld __cnfn convert_uint4_rtn(ushort4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(ushort4);
+uint4 __ovld __cnfn convert_uint4(ushort4);
+uint4 __ovld __cnfn convert_uint4_sat(ushort4);
+uint4 __ovld __cnfn convert_uint4_rte(int4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(int4);
+uint4 __ovld __cnfn convert_uint4_rtz(int4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(int4);
+uint4 __ovld __cnfn convert_uint4_rtp(int4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(int4);
+uint4 __ovld __cnfn convert_uint4_rtn(int4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(int4);
+uint4 __ovld __cnfn convert_uint4(int4);
+uint4 __ovld __cnfn convert_uint4_sat(int4);
+uint4 __ovld __cnfn convert_uint4_rte(uint4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(uint4);
+uint4 __ovld __cnfn convert_uint4_rtz(uint4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(uint4);
+uint4 __ovld __cnfn convert_uint4_rtp(uint4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(uint4);
+uint4 __ovld __cnfn convert_uint4_rtn(uint4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(uint4);
+uint4 __ovld __cnfn convert_uint4(uint4);
+uint4 __ovld __cnfn convert_uint4_sat(uint4);
+uint4 __ovld __cnfn convert_uint4_rte(long4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(long4);
+uint4 __ovld __cnfn convert_uint4_rtz(long4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(long4);
+uint4 __ovld __cnfn convert_uint4_rtp(long4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(long4);
+uint4 __ovld __cnfn convert_uint4_rtn(long4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(long4);
+uint4 __ovld __cnfn convert_uint4(long4);
+uint4 __ovld __cnfn convert_uint4_sat(long4);
+uint4 __ovld __cnfn convert_uint4_rte(ulong4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(ulong4);
+uint4 __ovld __cnfn convert_uint4_rtz(ulong4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(ulong4);
+uint4 __ovld __cnfn convert_uint4_rtp(ulong4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(ulong4);
+uint4 __ovld __cnfn convert_uint4_rtn(ulong4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(ulong4);
+uint4 __ovld __cnfn convert_uint4(ulong4);
+uint4 __ovld __cnfn convert_uint4_sat(ulong4);
+uint4 __ovld __cnfn convert_uint4_rte(float4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(float4);
+uint4 __ovld __cnfn convert_uint4_rtz(float4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(float4);
+uint4 __ovld __cnfn convert_uint4_rtp(float4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(float4);
+uint4 __ovld __cnfn convert_uint4_rtn(float4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(float4);
+uint4 __ovld __cnfn convert_uint4(float4);
+uint4 __ovld __cnfn convert_uint4_sat(float4);
+long4 __ovld __cnfn convert_long4_rte(char4);
+long4 __ovld __cnfn convert_long4_sat_rte(char4);
+long4 __ovld __cnfn convert_long4_rtz(char4);
+long4 __ovld __cnfn convert_long4_sat_rtz(char4);
+long4 __ovld __cnfn convert_long4_rtp(char4);
+long4 __ovld __cnfn convert_long4_sat_rtp(char4);
+long4 __ovld __cnfn convert_long4_rtn(char4);
+long4 __ovld __cnfn convert_long4_sat_rtn(char4);
+long4 __ovld __cnfn convert_long4(char4);
+long4 __ovld __cnfn convert_long4_sat(char4);
+long4 __ovld __cnfn convert_long4_rte(uchar4);
+long4 __ovld __cnfn convert_long4_sat_rte(uchar4);
+long4 __ovld __cnfn convert_long4_rtz(uchar4);
+long4 __ovld __cnfn convert_long4_sat_rtz(uchar4);
+long4 __ovld __cnfn convert_long4_rtp(uchar4);
+long4 __ovld __cnfn convert_long4_sat_rtp(uchar4);
+long4 __ovld __cnfn convert_long4_rtn(uchar4);
+long4 __ovld __cnfn convert_long4_sat_rtn(uchar4);
+long4 __ovld __cnfn convert_long4(uchar4);
+long4 __ovld __cnfn convert_long4_sat(uchar4);
+long4 __ovld __cnfn convert_long4_rte(short4);
+long4 __ovld __cnfn convert_long4_sat_rte(short4);
+long4 __ovld __cnfn convert_long4_rtz(short4);
+long4 __ovld __cnfn convert_long4_sat_rtz(short4);
+long4 __ovld __cnfn convert_long4_rtp(short4);
+long4 __ovld __cnfn convert_long4_sat_rtp(short4);
+long4 __ovld __cnfn convert_long4_rtn(short4);
+long4 __ovld __cnfn convert_long4_sat_rtn(short4);
+long4 __ovld __cnfn convert_long4(short4);
+long4 __ovld __cnfn convert_long4_sat(short4);
+long4 __ovld __cnfn convert_long4_rte(ushort4);
+long4 __ovld __cnfn convert_long4_sat_rte(ushort4);
+long4 __ovld __cnfn convert_long4_rtz(ushort4);
+long4 __ovld __cnfn convert_long4_sat_rtz(ushort4);
+long4 __ovld __cnfn convert_long4_rtp(ushort4);
+long4 __ovld __cnfn convert_long4_sat_rtp(ushort4);
+long4 __ovld __cnfn convert_long4_rtn(ushort4);
+long4 __ovld __cnfn convert_long4_sat_rtn(ushort4);
+long4 __ovld __cnfn convert_long4(ushort4);
+long4 __ovld __cnfn convert_long4_sat(ushort4);
+long4 __ovld __cnfn convert_long4_rte(int4);
+long4 __ovld __cnfn convert_long4_sat_rte(int4);
+long4 __ovld __cnfn convert_long4_rtz(int4);
+long4 __ovld __cnfn convert_long4_sat_rtz(int4);
+long4 __ovld __cnfn convert_long4_rtp(int4);
+long4 __ovld __cnfn convert_long4_sat_rtp(int4);
+long4 __ovld __cnfn convert_long4_rtn(int4);
+long4 __ovld __cnfn convert_long4_sat_rtn(int4);
+long4 __ovld __cnfn convert_long4(int4);
+long4 __ovld __cnfn convert_long4_sat(int4);
+long4 __ovld __cnfn convert_long4_rte(uint4);
+long4 __ovld __cnfn convert_long4_sat_rte(uint4);
+long4 __ovld __cnfn convert_long4_rtz(uint4);
+long4 __ovld __cnfn convert_long4_sat_rtz(uint4);
+long4 __ovld __cnfn convert_long4_rtp(uint4);
+long4 __ovld __cnfn convert_long4_sat_rtp(uint4);
+long4 __ovld __cnfn convert_long4_rtn(uint4);
+long4 __ovld __cnfn convert_long4_sat_rtn(uint4);
+long4 __ovld __cnfn convert_long4(uint4);
+long4 __ovld __cnfn convert_long4_sat(uint4);
+long4 __ovld __cnfn convert_long4_rte(long4);
+long4 __ovld __cnfn convert_long4_sat_rte(long4);
+long4 __ovld __cnfn convert_long4_rtz(long4);
+long4 __ovld __cnfn convert_long4_sat_rtz(long4);
+long4 __ovld __cnfn convert_long4_rtp(long4);
+long4 __ovld __cnfn convert_long4_sat_rtp(long4);
+long4 __ovld __cnfn convert_long4_rtn(long4);
+long4 __ovld __cnfn convert_long4_sat_rtn(long4);
+long4 __ovld __cnfn convert_long4(long4);
+long4 __ovld __cnfn convert_long4_sat(long4);
+long4 __ovld __cnfn convert_long4_rte(ulong4);
+long4 __ovld __cnfn convert_long4_sat_rte(ulong4);
+long4 __ovld __cnfn convert_long4_rtz(ulong4);
+long4 __ovld __cnfn convert_long4_sat_rtz(ulong4);
+long4 __ovld __cnfn convert_long4_rtp(ulong4);
+long4 __ovld __cnfn convert_long4_sat_rtp(ulong4);
+long4 __ovld __cnfn convert_long4_rtn(ulong4);
+long4 __ovld __cnfn convert_long4_sat_rtn(ulong4);
+long4 __ovld __cnfn convert_long4(ulong4);
+long4 __ovld __cnfn convert_long4_sat(ulong4);
+long4 __ovld __cnfn convert_long4_rte(float4);
+long4 __ovld __cnfn convert_long4_sat_rte(float4);
+long4 __ovld __cnfn convert_long4_rtz(float4);
+long4 __ovld __cnfn convert_long4_sat_rtz(float4);
+long4 __ovld __cnfn convert_long4_rtp(float4);
+long4 __ovld __cnfn convert_long4_sat_rtp(float4);
+long4 __ovld __cnfn convert_long4_rtn(float4);
+long4 __ovld __cnfn convert_long4_sat_rtn(float4);
+long4 __ovld __cnfn convert_long4(float4);
+long4 __ovld __cnfn convert_long4_sat(float4);
+ulong4 __ovld __cnfn convert_ulong4_rte(char4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(char4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(char4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(char4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(char4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(char4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(char4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(char4);
+ulong4 __ovld __cnfn convert_ulong4(char4);
+ulong4 __ovld __cnfn convert_ulong4_sat(char4);
+ulong4 __ovld __cnfn convert_ulong4_rte(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(uchar4);
+ulong4 __ovld __cnfn convert_ulong4(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_sat(uchar4);
+ulong4 __ovld __cnfn convert_ulong4_rte(short4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(short4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(short4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(short4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(short4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(short4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(short4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(short4);
+ulong4 __ovld __cnfn convert_ulong4(short4);
+ulong4 __ovld __cnfn convert_ulong4_sat(short4);
+ulong4 __ovld __cnfn convert_ulong4_rte(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(ushort4);
+ulong4 __ovld __cnfn convert_ulong4(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_sat(ushort4);
+ulong4 __ovld __cnfn convert_ulong4_rte(int4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(int4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(int4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(int4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(int4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(int4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(int4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(int4);
+ulong4 __ovld __cnfn convert_ulong4(int4);
+ulong4 __ovld __cnfn convert_ulong4_sat(int4);
+ulong4 __ovld __cnfn convert_ulong4_rte(uint4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(uint4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(uint4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(uint4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(uint4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(uint4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(uint4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(uint4);
+ulong4 __ovld __cnfn convert_ulong4(uint4);
+ulong4 __ovld __cnfn convert_ulong4_sat(uint4);
+ulong4 __ovld __cnfn convert_ulong4_rte(long4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(long4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(long4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(long4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(long4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(long4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(long4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(long4);
+ulong4 __ovld __cnfn convert_ulong4(long4);
+ulong4 __ovld __cnfn convert_ulong4_sat(long4);
+ulong4 __ovld __cnfn convert_ulong4_rte(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(ulong4);
+ulong4 __ovld __cnfn convert_ulong4(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_sat(ulong4);
+ulong4 __ovld __cnfn convert_ulong4_rte(float4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(float4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(float4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(float4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(float4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(float4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(float4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(float4);
+ulong4 __ovld __cnfn convert_ulong4(float4);
+ulong4 __ovld __cnfn convert_ulong4_sat(float4);
+float4 __ovld __cnfn convert_float4_rte(char4);
+float4 __ovld __cnfn convert_float4_rtz(char4);
+float4 __ovld __cnfn convert_float4_rtp(char4);
+float4 __ovld __cnfn convert_float4_rtn(char4);
+float4 __ovld __cnfn convert_float4(char4);
+float4 __ovld __cnfn convert_float4_rte(uchar4);
+float4 __ovld __cnfn convert_float4_rtz(uchar4);
+float4 __ovld __cnfn convert_float4_rtp(uchar4);
+float4 __ovld __cnfn convert_float4_rtn(uchar4);
+float4 __ovld __cnfn convert_float4(uchar4);
+float4 __ovld __cnfn convert_float4_rte(short4);
+float4 __ovld __cnfn convert_float4_rtz(short4);
+float4 __ovld __cnfn convert_float4_rtp(short4);
+float4 __ovld __cnfn convert_float4_rtn(short4);
+float4 __ovld __cnfn convert_float4(short4);
+float4 __ovld __cnfn convert_float4_rte(ushort4);
+float4 __ovld __cnfn convert_float4_rtz(ushort4);
+float4 __ovld __cnfn convert_float4_rtp(ushort4);
+float4 __ovld __cnfn convert_float4_rtn(ushort4);
+float4 __ovld __cnfn convert_float4(ushort4);
+float4 __ovld __cnfn convert_float4_rte(int4);
+float4 __ovld __cnfn convert_float4_rtz(int4);
+float4 __ovld __cnfn convert_float4_rtp(int4);
+float4 __ovld __cnfn convert_float4_rtn(int4);
+float4 __ovld __cnfn convert_float4(int4);
+float4 __ovld __cnfn convert_float4_rte(uint4);
+float4 __ovld __cnfn convert_float4_rtz(uint4);
+float4 __ovld __cnfn convert_float4_rtp(uint4);
+float4 __ovld __cnfn convert_float4_rtn(uint4);
+float4 __ovld __cnfn convert_float4(uint4);
+float4 __ovld __cnfn convert_float4_rte(long4);
+float4 __ovld __cnfn convert_float4_rtz(long4);
+float4 __ovld __cnfn convert_float4_rtp(long4);
+float4 __ovld __cnfn convert_float4_rtn(long4);
+float4 __ovld __cnfn convert_float4(long4);
+float4 __ovld __cnfn convert_float4_rte(ulong4);
+float4 __ovld __cnfn convert_float4_rtz(ulong4);
+float4 __ovld __cnfn convert_float4_rtp(ulong4);
+float4 __ovld __cnfn convert_float4_rtn(ulong4);
+float4 __ovld __cnfn convert_float4(ulong4);
+float4 __ovld __cnfn convert_float4_rte(float4);
+float4 __ovld __cnfn convert_float4_rtz(float4);
+float4 __ovld __cnfn convert_float4_rtp(float4);
+float4 __ovld __cnfn convert_float4_rtn(float4);
+float4 __ovld __cnfn convert_float4(float4);
+char8 __ovld __cnfn convert_char8_rte(char8);
+char8 __ovld __cnfn convert_char8_sat_rte(char8);
+char8 __ovld __cnfn convert_char8_rtz(char8);
+char8 __ovld __cnfn convert_char8_sat_rtz(char8);
+char8 __ovld __cnfn convert_char8_rtp(char8);
+char8 __ovld __cnfn convert_char8_sat_rtp(char8);
+char8 __ovld __cnfn convert_char8_rtn(char8);
+char8 __ovld __cnfn convert_char8_sat_rtn(char8);
+char8 __ovld __cnfn convert_char8(char8);
+char8 __ovld __cnfn convert_char8_sat(char8);
+char8 __ovld __cnfn convert_char8_rte(uchar8);
+char8 __ovld __cnfn convert_char8_sat_rte(uchar8);
+char8 __ovld __cnfn convert_char8_rtz(uchar8);
+char8 __ovld __cnfn convert_char8_sat_rtz(uchar8);
+char8 __ovld __cnfn convert_char8_rtp(uchar8);
+char8 __ovld __cnfn convert_char8_sat_rtp(uchar8);
+char8 __ovld __cnfn convert_char8_rtn(uchar8);
+char8 __ovld __cnfn convert_char8_sat_rtn(uchar8);
+char8 __ovld __cnfn convert_char8(uchar8);
+char8 __ovld __cnfn convert_char8_sat(uchar8);
+char8 __ovld __cnfn convert_char8_rte(short8);
+char8 __ovld __cnfn convert_char8_sat_rte(short8);
+char8 __ovld __cnfn convert_char8_rtz(short8);
+char8 __ovld __cnfn convert_char8_sat_rtz(short8);
+char8 __ovld __cnfn convert_char8_rtp(short8);
+char8 __ovld __cnfn convert_char8_sat_rtp(short8);
+char8 __ovld __cnfn convert_char8_rtn(short8);
+char8 __ovld __cnfn convert_char8_sat_rtn(short8);
+char8 __ovld __cnfn convert_char8(short8);
+char8 __ovld __cnfn convert_char8_sat(short8);
+char8 __ovld __cnfn convert_char8_rte(ushort8);
+char8 __ovld __cnfn convert_char8_sat_rte(ushort8);
+char8 __ovld __cnfn convert_char8_rtz(ushort8);
+char8 __ovld __cnfn convert_char8_sat_rtz(ushort8);
+char8 __ovld __cnfn convert_char8_rtp(ushort8);
+char8 __ovld __cnfn convert_char8_sat_rtp(ushort8);
+char8 __ovld __cnfn convert_char8_rtn(ushort8);
+char8 __ovld __cnfn convert_char8_sat_rtn(ushort8);
+char8 __ovld __cnfn convert_char8(ushort8);
+char8 __ovld __cnfn convert_char8_sat(ushort8);
+char8 __ovld __cnfn convert_char8_rte(int8);
+char8 __ovld __cnfn convert_char8_sat_rte(int8);
+char8 __ovld __cnfn convert_char8_rtz(int8);
+char8 __ovld __cnfn convert_char8_sat_rtz(int8);
+char8 __ovld __cnfn convert_char8_rtp(int8);
+char8 __ovld __cnfn convert_char8_sat_rtp(int8);
+char8 __ovld __cnfn convert_char8_rtn(int8);
+char8 __ovld __cnfn convert_char8_sat_rtn(int8);
+char8 __ovld __cnfn convert_char8(int8);
+char8 __ovld __cnfn convert_char8_sat(int8);
+char8 __ovld __cnfn convert_char8_rte(uint8);
+char8 __ovld __cnfn convert_char8_sat_rte(uint8);
+char8 __ovld __cnfn convert_char8_rtz(uint8);
+char8 __ovld __cnfn convert_char8_sat_rtz(uint8);
+char8 __ovld __cnfn convert_char8_rtp(uint8);
+char8 __ovld __cnfn convert_char8_sat_rtp(uint8);
+char8 __ovld __cnfn convert_char8_rtn(uint8);
+char8 __ovld __cnfn convert_char8_sat_rtn(uint8);
+char8 __ovld __cnfn convert_char8(uint8);
+char8 __ovld __cnfn convert_char8_sat(uint8);
+char8 __ovld __cnfn convert_char8_rte(long8);
+char8 __ovld __cnfn convert_char8_sat_rte(long8);
+char8 __ovld __cnfn convert_char8_rtz(long8);
+char8 __ovld __cnfn convert_char8_sat_rtz(long8);
+char8 __ovld __cnfn convert_char8_rtp(long8);
+char8 __ovld __cnfn convert_char8_sat_rtp(long8);
+char8 __ovld __cnfn convert_char8_rtn(long8);
+char8 __ovld __cnfn convert_char8_sat_rtn(long8);
+char8 __ovld __cnfn convert_char8(long8);
+char8 __ovld __cnfn convert_char8_sat(long8);
+char8 __ovld __cnfn convert_char8_rte(ulong8);
+char8 __ovld __cnfn convert_char8_sat_rte(ulong8);
+char8 __ovld __cnfn convert_char8_rtz(ulong8);
+char8 __ovld __cnfn convert_char8_sat_rtz(ulong8);
+char8 __ovld __cnfn convert_char8_rtp(ulong8);
+char8 __ovld __cnfn convert_char8_sat_rtp(ulong8);
+char8 __ovld __cnfn convert_char8_rtn(ulong8);
+char8 __ovld __cnfn convert_char8_sat_rtn(ulong8);
+char8 __ovld __cnfn convert_char8(ulong8);
+char8 __ovld __cnfn convert_char8_sat(ulong8);
+char8 __ovld __cnfn convert_char8_rte(float8);
+char8 __ovld __cnfn convert_char8_sat_rte(float8);
+char8 __ovld __cnfn convert_char8_rtz(float8);
+char8 __ovld __cnfn convert_char8_sat_rtz(float8);
+char8 __ovld __cnfn convert_char8_rtp(float8);
+char8 __ovld __cnfn convert_char8_sat_rtp(float8);
+char8 __ovld __cnfn convert_char8_rtn(float8);
+char8 __ovld __cnfn convert_char8_sat_rtn(float8);
+char8 __ovld __cnfn convert_char8(float8);
+char8 __ovld __cnfn convert_char8_sat(float8);
+uchar8 __ovld __cnfn convert_uchar8_rte(char8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(char8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(char8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(char8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(char8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(char8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(char8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(char8);
+uchar8 __ovld __cnfn convert_uchar8(char8);
+uchar8 __ovld __cnfn convert_uchar8_sat(char8);
+uchar8 __ovld __cnfn convert_uchar8_rte(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(uchar8);
+uchar8 __ovld __cnfn convert_uchar8(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_sat(uchar8);
+uchar8 __ovld __cnfn convert_uchar8_rte(short8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(short8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(short8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(short8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(short8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(short8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(short8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(short8);
+uchar8 __ovld __cnfn convert_uchar8(short8);
+uchar8 __ovld __cnfn convert_uchar8_sat(short8);
+uchar8 __ovld __cnfn convert_uchar8_rte(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(ushort8);
+uchar8 __ovld __cnfn convert_uchar8(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_sat(ushort8);
+uchar8 __ovld __cnfn convert_uchar8_rte(int8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(int8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(int8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(int8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(int8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(int8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(int8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(int8);
+uchar8 __ovld __cnfn convert_uchar8(int8);
+uchar8 __ovld __cnfn convert_uchar8_sat(int8);
+uchar8 __ovld __cnfn convert_uchar8_rte(uint8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(uint8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(uint8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(uint8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(uint8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(uint8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(uint8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(uint8);
+uchar8 __ovld __cnfn convert_uchar8(uint8);
+uchar8 __ovld __cnfn convert_uchar8_sat(uint8);
+uchar8 __ovld __cnfn convert_uchar8_rte(long8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(long8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(long8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(long8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(long8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(long8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(long8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(long8);
+uchar8 __ovld __cnfn convert_uchar8(long8);
+uchar8 __ovld __cnfn convert_uchar8_sat(long8);
+uchar8 __ovld __cnfn convert_uchar8_rte(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(ulong8);
+uchar8 __ovld __cnfn convert_uchar8(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_sat(ulong8);
+uchar8 __ovld __cnfn convert_uchar8_rte(float8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(float8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(float8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(float8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(float8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(float8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(float8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(float8);
+uchar8 __ovld __cnfn convert_uchar8(float8);
+uchar8 __ovld __cnfn convert_uchar8_sat(float8);
+short8 __ovld __cnfn convert_short8_rte(char8);
+short8 __ovld __cnfn convert_short8_sat_rte(char8);
+short8 __ovld __cnfn convert_short8_rtz(char8);
+short8 __ovld __cnfn convert_short8_sat_rtz(char8);
+short8 __ovld __cnfn convert_short8_rtp(char8);
+short8 __ovld __cnfn convert_short8_sat_rtp(char8);
+short8 __ovld __cnfn convert_short8_rtn(char8);
+short8 __ovld __cnfn convert_short8_sat_rtn(char8);
+short8 __ovld __cnfn convert_short8(char8);
+short8 __ovld __cnfn convert_short8_sat(char8);
+short8 __ovld __cnfn convert_short8_rte(uchar8);
+short8 __ovld __cnfn convert_short8_sat_rte(uchar8);
+short8 __ovld __cnfn convert_short8_rtz(uchar8);
+short8 __ovld __cnfn convert_short8_sat_rtz(uchar8);
+short8 __ovld __cnfn convert_short8_rtp(uchar8);
+short8 __ovld __cnfn convert_short8_sat_rtp(uchar8);
+short8 __ovld __cnfn convert_short8_rtn(uchar8);
+short8 __ovld __cnfn convert_short8_sat_rtn(uchar8);
+short8 __ovld __cnfn convert_short8(uchar8);
+short8 __ovld __cnfn convert_short8_sat(uchar8);
+short8 __ovld __cnfn convert_short8_rte(short8);
+short8 __ovld __cnfn convert_short8_sat_rte(short8);
+short8 __ovld __cnfn convert_short8_rtz(short8);
+short8 __ovld __cnfn convert_short8_sat_rtz(short8);
+short8 __ovld __cnfn convert_short8_rtp(short8);
+short8 __ovld __cnfn convert_short8_sat_rtp(short8);
+short8 __ovld __cnfn convert_short8_rtn(short8);
+short8 __ovld __cnfn convert_short8_sat_rtn(short8);
+short8 __ovld __cnfn convert_short8(short8);
+short8 __ovld __cnfn convert_short8_sat(short8);
+short8 __ovld __cnfn convert_short8_rte(ushort8);
+short8 __ovld __cnfn convert_short8_sat_rte(ushort8);
+short8 __ovld __cnfn convert_short8_rtz(ushort8);
+short8 __ovld __cnfn convert_short8_sat_rtz(ushort8);
+short8 __ovld __cnfn convert_short8_rtp(ushort8);
+short8 __ovld __cnfn convert_short8_sat_rtp(ushort8);
+short8 __ovld __cnfn convert_short8_rtn(ushort8);
+short8 __ovld __cnfn convert_short8_sat_rtn(ushort8);
+short8 __ovld __cnfn convert_short8(ushort8);
+short8 __ovld __cnfn convert_short8_sat(ushort8);
+short8 __ovld __cnfn convert_short8_rte(int8);
+short8 __ovld __cnfn convert_short8_sat_rte(int8);
+short8 __ovld __cnfn convert_short8_rtz(int8);
+short8 __ovld __cnfn convert_short8_sat_rtz(int8);
+short8 __ovld __cnfn convert_short8_rtp(int8);
+short8 __ovld __cnfn convert_short8_sat_rtp(int8);
+short8 __ovld __cnfn convert_short8_rtn(int8);
+short8 __ovld __cnfn convert_short8_sat_rtn(int8);
+short8 __ovld __cnfn convert_short8(int8);
+short8 __ovld __cnfn convert_short8_sat(int8);
+short8 __ovld __cnfn convert_short8_rte(uint8);
+short8 __ovld __cnfn convert_short8_sat_rte(uint8);
+short8 __ovld __cnfn convert_short8_rtz(uint8);
+short8 __ovld __cnfn convert_short8_sat_rtz(uint8);
+short8 __ovld __cnfn convert_short8_rtp(uint8);
+short8 __ovld __cnfn convert_short8_sat_rtp(uint8);
+short8 __ovld __cnfn convert_short8_rtn(uint8);
+short8 __ovld __cnfn convert_short8_sat_rtn(uint8);
+short8 __ovld __cnfn convert_short8(uint8);
+short8 __ovld __cnfn convert_short8_sat(uint8);
+short8 __ovld __cnfn convert_short8_rte(long8);
+short8 __ovld __cnfn convert_short8_sat_rte(long8);
+short8 __ovld __cnfn convert_short8_rtz(long8);
+short8 __ovld __cnfn convert_short8_sat_rtz(long8);
+short8 __ovld __cnfn convert_short8_rtp(long8);
+short8 __ovld __cnfn convert_short8_sat_rtp(long8);
+short8 __ovld __cnfn convert_short8_rtn(long8);
+short8 __ovld __cnfn convert_short8_sat_rtn(long8);
+short8 __ovld __cnfn convert_short8(long8);
+short8 __ovld __cnfn convert_short8_sat(long8);
+short8 __ovld __cnfn convert_short8_rte(ulong8);
+short8 __ovld __cnfn convert_short8_sat_rte(ulong8);
+short8 __ovld __cnfn convert_short8_rtz(ulong8);
+short8 __ovld __cnfn convert_short8_sat_rtz(ulong8);
+short8 __ovld __cnfn convert_short8_rtp(ulong8);
+short8 __ovld __cnfn convert_short8_sat_rtp(ulong8);
+short8 __ovld __cnfn convert_short8_rtn(ulong8);
+short8 __ovld __cnfn convert_short8_sat_rtn(ulong8);
+short8 __ovld __cnfn convert_short8(ulong8);
+short8 __ovld __cnfn convert_short8_sat(ulong8);
+short8 __ovld __cnfn convert_short8_rte(float8);
+short8 __ovld __cnfn convert_short8_sat_rte(float8);
+short8 __ovld __cnfn convert_short8_rtz(float8);
+short8 __ovld __cnfn convert_short8_sat_rtz(float8);
+short8 __ovld __cnfn convert_short8_rtp(float8);
+short8 __ovld __cnfn convert_short8_sat_rtp(float8);
+short8 __ovld __cnfn convert_short8_rtn(float8);
+short8 __ovld __cnfn convert_short8_sat_rtn(float8);
+short8 __ovld __cnfn convert_short8(float8);
+short8 __ovld __cnfn convert_short8_sat(float8);
+ushort8 __ovld __cnfn convert_ushort8_rte(char8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(char8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(char8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(char8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(char8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(char8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(char8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(char8);
+ushort8 __ovld __cnfn convert_ushort8(char8);
+ushort8 __ovld __cnfn convert_ushort8_sat(char8);
+ushort8 __ovld __cnfn convert_ushort8_rte(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(uchar8);
+ushort8 __ovld __cnfn convert_ushort8(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_sat(uchar8);
+ushort8 __ovld __cnfn convert_ushort8_rte(short8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(short8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(short8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(short8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(short8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(short8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(short8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(short8);
+ushort8 __ovld __cnfn convert_ushort8(short8);
+ushort8 __ovld __cnfn convert_ushort8_sat(short8);
+ushort8 __ovld __cnfn convert_ushort8_rte(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(ushort8);
+ushort8 __ovld __cnfn convert_ushort8(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_sat(ushort8);
+ushort8 __ovld __cnfn convert_ushort8_rte(int8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(int8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(int8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(int8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(int8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(int8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(int8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(int8);
+ushort8 __ovld __cnfn convert_ushort8(int8);
+ushort8 __ovld __cnfn convert_ushort8_sat(int8);
+ushort8 __ovld __cnfn convert_ushort8_rte(uint8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(uint8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(uint8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(uint8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(uint8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(uint8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(uint8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(uint8);
+ushort8 __ovld __cnfn convert_ushort8(uint8);
+ushort8 __ovld __cnfn convert_ushort8_sat(uint8);
+ushort8 __ovld __cnfn convert_ushort8_rte(long8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(long8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(long8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(long8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(long8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(long8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(long8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(long8);
+ushort8 __ovld __cnfn convert_ushort8(long8);
+ushort8 __ovld __cnfn convert_ushort8_sat(long8);
+ushort8 __ovld __cnfn convert_ushort8_rte(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(ulong8);
+ushort8 __ovld __cnfn convert_ushort8(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_sat(ulong8);
+ushort8 __ovld __cnfn convert_ushort8_rte(float8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(float8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(float8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(float8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(float8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(float8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(float8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(float8);
+ushort8 __ovld __cnfn convert_ushort8(float8);
+ushort8 __ovld __cnfn convert_ushort8_sat(float8);
+int8 __ovld __cnfn convert_int8_rte(char8);
+int8 __ovld __cnfn convert_int8_sat_rte(char8);
+int8 __ovld __cnfn convert_int8_rtz(char8);
+int8 __ovld __cnfn convert_int8_sat_rtz(char8);
+int8 __ovld __cnfn convert_int8_rtp(char8);
+int8 __ovld __cnfn convert_int8_sat_rtp(char8);
+int8 __ovld __cnfn convert_int8_rtn(char8);
+int8 __ovld __cnfn convert_int8_sat_rtn(char8);
+int8 __ovld __cnfn convert_int8(char8);
+int8 __ovld __cnfn convert_int8_sat(char8);
+int8 __ovld __cnfn convert_int8_rte(uchar8);
+int8 __ovld __cnfn convert_int8_sat_rte(uchar8);
+int8 __ovld __cnfn convert_int8_rtz(uchar8);
+int8 __ovld __cnfn convert_int8_sat_rtz(uchar8);
+int8 __ovld __cnfn convert_int8_rtp(uchar8);
+int8 __ovld __cnfn convert_int8_sat_rtp(uchar8);
+int8 __ovld __cnfn convert_int8_rtn(uchar8);
+int8 __ovld __cnfn convert_int8_sat_rtn(uchar8);
+int8 __ovld __cnfn convert_int8(uchar8);
+int8 __ovld __cnfn convert_int8_sat(uchar8);
+int8 __ovld __cnfn convert_int8_rte(short8);
+int8 __ovld __cnfn convert_int8_sat_rte(short8);
+int8 __ovld __cnfn convert_int8_rtz(short8);
+int8 __ovld __cnfn convert_int8_sat_rtz(short8);
+int8 __ovld __cnfn convert_int8_rtp(short8);
+int8 __ovld __cnfn convert_int8_sat_rtp(short8);
+int8 __ovld __cnfn convert_int8_rtn(short8);
+int8 __ovld __cnfn convert_int8_sat_rtn(short8);
+int8 __ovld __cnfn convert_int8(short8);
+int8 __ovld __cnfn convert_int8_sat(short8);
+int8 __ovld __cnfn convert_int8_rte(ushort8);
+int8 __ovld __cnfn convert_int8_sat_rte(ushort8);
+int8 __ovld __cnfn convert_int8_rtz(ushort8);
+int8 __ovld __cnfn convert_int8_sat_rtz(ushort8);
+int8 __ovld __cnfn convert_int8_rtp(ushort8);
+int8 __ovld __cnfn convert_int8_sat_rtp(ushort8);
+int8 __ovld __cnfn convert_int8_rtn(ushort8);
+int8 __ovld __cnfn convert_int8_sat_rtn(ushort8);
+int8 __ovld __cnfn convert_int8(ushort8);
+int8 __ovld __cnfn convert_int8_sat(ushort8);
+int8 __ovld __cnfn convert_int8_rte(int8);
+int8 __ovld __cnfn convert_int8_sat_rte(int8);
+int8 __ovld __cnfn convert_int8_rtz(int8);
+int8 __ovld __cnfn convert_int8_sat_rtz(int8);
+int8 __ovld __cnfn convert_int8_rtp(int8);
+int8 __ovld __cnfn convert_int8_sat_rtp(int8);
+int8 __ovld __cnfn convert_int8_rtn(int8);
+int8 __ovld __cnfn convert_int8_sat_rtn(int8);
+int8 __ovld __cnfn convert_int8(int8);
+int8 __ovld __cnfn convert_int8_sat(int8);
+int8 __ovld __cnfn convert_int8_rte(uint8);
+int8 __ovld __cnfn convert_int8_sat_rte(uint8);
+int8 __ovld __cnfn convert_int8_rtz(uint8);
+int8 __ovld __cnfn convert_int8_sat_rtz(uint8);
+int8 __ovld __cnfn convert_int8_rtp(uint8);
+int8 __ovld __cnfn convert_int8_sat_rtp(uint8);
+int8 __ovld __cnfn convert_int8_rtn(uint8);
+int8 __ovld __cnfn convert_int8_sat_rtn(uint8);
+int8 __ovld __cnfn convert_int8(uint8);
+int8 __ovld __cnfn convert_int8_sat(uint8);
+int8 __ovld __cnfn convert_int8_rte(long8);
+int8 __ovld __cnfn convert_int8_sat_rte(long8);
+int8 __ovld __cnfn convert_int8_rtz(long8);
+int8 __ovld __cnfn convert_int8_sat_rtz(long8);
+int8 __ovld __cnfn convert_int8_rtp(long8);
+int8 __ovld __cnfn convert_int8_sat_rtp(long8);
+int8 __ovld __cnfn convert_int8_rtn(long8);
+int8 __ovld __cnfn convert_int8_sat_rtn(long8);
+int8 __ovld __cnfn convert_int8(long8);
+int8 __ovld __cnfn convert_int8_sat(long8);
+int8 __ovld __cnfn convert_int8_rte(ulong8);
+int8 __ovld __cnfn convert_int8_sat_rte(ulong8);
+int8 __ovld __cnfn convert_int8_rtz(ulong8);
+int8 __ovld __cnfn convert_int8_sat_rtz(ulong8);
+int8 __ovld __cnfn convert_int8_rtp(ulong8);
+int8 __ovld __cnfn convert_int8_sat_rtp(ulong8);
+int8 __ovld __cnfn convert_int8_rtn(ulong8);
+int8 __ovld __cnfn convert_int8_sat_rtn(ulong8);
+int8 __ovld __cnfn convert_int8(ulong8);
+int8 __ovld __cnfn convert_int8_sat(ulong8);
+int8 __ovld __cnfn convert_int8_rte(float8);
+int8 __ovld __cnfn convert_int8_sat_rte(float8);
+int8 __ovld __cnfn convert_int8_rtz(float8);
+int8 __ovld __cnfn convert_int8_sat_rtz(float8);
+int8 __ovld __cnfn convert_int8_rtp(float8);
+int8 __ovld __cnfn convert_int8_sat_rtp(float8);
+int8 __ovld __cnfn convert_int8_rtn(float8);
+int8 __ovld __cnfn convert_int8_sat_rtn(float8);
+int8 __ovld __cnfn convert_int8(float8);
+int8 __ovld __cnfn convert_int8_sat(float8);
+uint8 __ovld __cnfn convert_uint8_rte(char8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(char8);
+uint8 __ovld __cnfn convert_uint8_rtz(char8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(char8);
+uint8 __ovld __cnfn convert_uint8_rtp(char8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(char8);
+uint8 __ovld __cnfn convert_uint8_rtn(char8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(char8);
+uint8 __ovld __cnfn convert_uint8(char8);
+uint8 __ovld __cnfn convert_uint8_sat(char8);
+uint8 __ovld __cnfn convert_uint8_rte(uchar8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(uchar8);
+uint8 __ovld __cnfn convert_uint8_rtz(uchar8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(uchar8);
+uint8 __ovld __cnfn convert_uint8_rtp(uchar8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(uchar8);
+uint8 __ovld __cnfn convert_uint8_rtn(uchar8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(uchar8);
+uint8 __ovld __cnfn convert_uint8(uchar8);
+uint8 __ovld __cnfn convert_uint8_sat(uchar8);
+uint8 __ovld __cnfn convert_uint8_rte(short8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(short8);
+uint8 __ovld __cnfn convert_uint8_rtz(short8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(short8);
+uint8 __ovld __cnfn convert_uint8_rtp(short8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(short8);
+uint8 __ovld __cnfn convert_uint8_rtn(short8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(short8);
+uint8 __ovld __cnfn convert_uint8(short8);
+uint8 __ovld __cnfn convert_uint8_sat(short8);
+uint8 __ovld __cnfn convert_uint8_rte(ushort8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(ushort8);
+uint8 __ovld __cnfn convert_uint8_rtz(ushort8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(ushort8);
+uint8 __ovld __cnfn convert_uint8_rtp(ushort8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(ushort8);
+uint8 __ovld __cnfn convert_uint8_rtn(ushort8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(ushort8);
+uint8 __ovld __cnfn convert_uint8(ushort8);
+uint8 __ovld __cnfn convert_uint8_sat(ushort8);
+uint8 __ovld __cnfn convert_uint8_rte(int8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(int8);
+uint8 __ovld __cnfn convert_uint8_rtz(int8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(int8);
+uint8 __ovld __cnfn convert_uint8_rtp(int8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(int8);
+uint8 __ovld __cnfn convert_uint8_rtn(int8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(int8);
+uint8 __ovld __cnfn convert_uint8(int8);
+uint8 __ovld __cnfn convert_uint8_sat(int8);
+uint8 __ovld __cnfn convert_uint8_rte(uint8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(uint8);
+uint8 __ovld __cnfn convert_uint8_rtz(uint8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(uint8);
+uint8 __ovld __cnfn convert_uint8_rtp(uint8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(uint8);
+uint8 __ovld __cnfn convert_uint8_rtn(uint8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(uint8);
+uint8 __ovld __cnfn convert_uint8(uint8);
+uint8 __ovld __cnfn convert_uint8_sat(uint8);
+uint8 __ovld __cnfn convert_uint8_rte(long8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(long8);
+uint8 __ovld __cnfn convert_uint8_rtz(long8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(long8);
+uint8 __ovld __cnfn convert_uint8_rtp(long8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(long8);
+uint8 __ovld __cnfn convert_uint8_rtn(long8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(long8);
+uint8 __ovld __cnfn convert_uint8(long8);
+uint8 __ovld __cnfn convert_uint8_sat(long8);
+uint8 __ovld __cnfn convert_uint8_rte(ulong8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(ulong8);
+uint8 __ovld __cnfn convert_uint8_rtz(ulong8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(ulong8);
+uint8 __ovld __cnfn convert_uint8_rtp(ulong8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(ulong8);
+uint8 __ovld __cnfn convert_uint8_rtn(ulong8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(ulong8);
+uint8 __ovld __cnfn convert_uint8(ulong8);
+uint8 __ovld __cnfn convert_uint8_sat(ulong8);
+uint8 __ovld __cnfn convert_uint8_rte(float8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(float8);
+uint8 __ovld __cnfn convert_uint8_rtz(float8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(float8);
+uint8 __ovld __cnfn convert_uint8_rtp(float8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(float8);
+uint8 __ovld __cnfn convert_uint8_rtn(float8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(float8);
+uint8 __ovld __cnfn convert_uint8(float8);
+uint8 __ovld __cnfn convert_uint8_sat(float8);
+long8 __ovld __cnfn convert_long8_rte(char8);
+long8 __ovld __cnfn convert_long8_sat_rte(char8);
+long8 __ovld __cnfn convert_long8_rtz(char8);
+long8 __ovld __cnfn convert_long8_sat_rtz(char8);
+long8 __ovld __cnfn convert_long8_rtp(char8);
+long8 __ovld __cnfn convert_long8_sat_rtp(char8);
+long8 __ovld __cnfn convert_long8_rtn(char8);
+long8 __ovld __cnfn convert_long8_sat_rtn(char8);
+long8 __ovld __cnfn convert_long8(char8);
+long8 __ovld __cnfn convert_long8_sat(char8);
+long8 __ovld __cnfn convert_long8_rte(uchar8);
+long8 __ovld __cnfn convert_long8_sat_rte(uchar8);
+long8 __ovld __cnfn convert_long8_rtz(uchar8);
+long8 __ovld __cnfn convert_long8_sat_rtz(uchar8);
+long8 __ovld __cnfn convert_long8_rtp(uchar8);
+long8 __ovld __cnfn convert_long8_sat_rtp(uchar8);
+long8 __ovld __cnfn convert_long8_rtn(uchar8);
+long8 __ovld __cnfn convert_long8_sat_rtn(uchar8);
+long8 __ovld __cnfn convert_long8(uchar8);
+long8 __ovld __cnfn convert_long8_sat(uchar8);
+long8 __ovld __cnfn convert_long8_rte(short8);
+long8 __ovld __cnfn convert_long8_sat_rte(short8);
+long8 __ovld __cnfn convert_long8_rtz(short8);
+long8 __ovld __cnfn convert_long8_sat_rtz(short8);
+long8 __ovld __cnfn convert_long8_rtp(short8);
+long8 __ovld __cnfn convert_long8_sat_rtp(short8);
+long8 __ovld __cnfn convert_long8_rtn(short8);
+long8 __ovld __cnfn convert_long8_sat_rtn(short8);
+long8 __ovld __cnfn convert_long8(short8);
+long8 __ovld __cnfn convert_long8_sat(short8);
+long8 __ovld __cnfn convert_long8_rte(ushort8);
+long8 __ovld __cnfn convert_long8_sat_rte(ushort8);
+long8 __ovld __cnfn convert_long8_rtz(ushort8);
+long8 __ovld __cnfn convert_long8_sat_rtz(ushort8);
+long8 __ovld __cnfn convert_long8_rtp(ushort8);
+long8 __ovld __cnfn convert_long8_sat_rtp(ushort8);
+long8 __ovld __cnfn convert_long8_rtn(ushort8);
+long8 __ovld __cnfn convert_long8_sat_rtn(ushort8);
+long8 __ovld __cnfn convert_long8(ushort8);
+long8 __ovld __cnfn convert_long8_sat(ushort8);
+long8 __ovld __cnfn convert_long8_rte(int8);
+long8 __ovld __cnfn convert_long8_sat_rte(int8);
+long8 __ovld __cnfn convert_long8_rtz(int8);
+long8 __ovld __cnfn convert_long8_sat_rtz(int8);
+long8 __ovld __cnfn convert_long8_rtp(int8);
+long8 __ovld __cnfn convert_long8_sat_rtp(int8);
+long8 __ovld __cnfn convert_long8_rtn(int8);
+long8 __ovld __cnfn convert_long8_sat_rtn(int8);
+long8 __ovld __cnfn convert_long8(int8);
+long8 __ovld __cnfn convert_long8_sat(int8);
+long8 __ovld __cnfn convert_long8_rte(uint8);
+long8 __ovld __cnfn convert_long8_sat_rte(uint8);
+long8 __ovld __cnfn convert_long8_rtz(uint8);
+long8 __ovld __cnfn convert_long8_sat_rtz(uint8);
+long8 __ovld __cnfn convert_long8_rtp(uint8);
+long8 __ovld __cnfn convert_long8_sat_rtp(uint8);
+long8 __ovld __cnfn convert_long8_rtn(uint8);
+long8 __ovld __cnfn convert_long8_sat_rtn(uint8);
+long8 __ovld __cnfn convert_long8(uint8);
+long8 __ovld __cnfn convert_long8_sat(uint8);
+long8 __ovld __cnfn convert_long8_rte(long8);
+long8 __ovld __cnfn convert_long8_sat_rte(long8);
+long8 __ovld __cnfn convert_long8_rtz(long8);
+long8 __ovld __cnfn convert_long8_sat_rtz(long8);
+long8 __ovld __cnfn convert_long8_rtp(long8);
+long8 __ovld __cnfn convert_long8_sat_rtp(long8);
+long8 __ovld __cnfn convert_long8_rtn(long8);
+long8 __ovld __cnfn convert_long8_sat_rtn(long8);
+long8 __ovld __cnfn convert_long8(long8);
+long8 __ovld __cnfn convert_long8_sat(long8);
+long8 __ovld __cnfn convert_long8_rte(ulong8);
+long8 __ovld __cnfn convert_long8_sat_rte(ulong8);
+long8 __ovld __cnfn convert_long8_rtz(ulong8);
+long8 __ovld __cnfn convert_long8_sat_rtz(ulong8);
+long8 __ovld __cnfn convert_long8_rtp(ulong8);
+long8 __ovld __cnfn convert_long8_sat_rtp(ulong8);
+long8 __ovld __cnfn convert_long8_rtn(ulong8);
+long8 __ovld __cnfn convert_long8_sat_rtn(ulong8);
+long8 __ovld __cnfn convert_long8(ulong8);
+long8 __ovld __cnfn convert_long8_sat(ulong8);
+long8 __ovld __cnfn convert_long8_rte(float8);
+long8 __ovld __cnfn convert_long8_sat_rte(float8);
+long8 __ovld __cnfn convert_long8_rtz(float8);
+long8 __ovld __cnfn convert_long8_sat_rtz(float8);
+long8 __ovld __cnfn convert_long8_rtp(float8);
+long8 __ovld __cnfn convert_long8_sat_rtp(float8);
+long8 __ovld __cnfn convert_long8_rtn(float8);
+long8 __ovld __cnfn convert_long8_sat_rtn(float8);
+long8 __ovld __cnfn convert_long8(float8);
+long8 __ovld __cnfn convert_long8_sat(float8);
+ulong8 __ovld __cnfn convert_ulong8_rte(char8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(char8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(char8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(char8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(char8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(char8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(char8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(char8);
+ulong8 __ovld __cnfn convert_ulong8(char8);
+ulong8 __ovld __cnfn convert_ulong8_sat(char8);
+ulong8 __ovld __cnfn convert_ulong8_rte(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(uchar8);
+ulong8 __ovld __cnfn convert_ulong8(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_sat(uchar8);
+ulong8 __ovld __cnfn convert_ulong8_rte(short8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(short8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(short8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(short8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(short8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(short8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(short8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(short8);
+ulong8 __ovld __cnfn convert_ulong8(short8);
+ulong8 __ovld __cnfn convert_ulong8_sat(short8);
+ulong8 __ovld __cnfn convert_ulong8_rte(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(ushort8);
+ulong8 __ovld __cnfn convert_ulong8(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_sat(ushort8);
+ulong8 __ovld __cnfn convert_ulong8_rte(int8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(int8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(int8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(int8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(int8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(int8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(int8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(int8);
+ulong8 __ovld __cnfn convert_ulong8(int8);
+ulong8 __ovld __cnfn convert_ulong8_sat(int8);
+ulong8 __ovld __cnfn convert_ulong8_rte(uint8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(uint8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(uint8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(uint8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(uint8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(uint8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(uint8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(uint8);
+ulong8 __ovld __cnfn convert_ulong8(uint8);
+ulong8 __ovld __cnfn convert_ulong8_sat(uint8);
+ulong8 __ovld __cnfn convert_ulong8_rte(long8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(long8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(long8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(long8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(long8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(long8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(long8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(long8);
+ulong8 __ovld __cnfn convert_ulong8(long8);
+ulong8 __ovld __cnfn convert_ulong8_sat(long8);
+ulong8 __ovld __cnfn convert_ulong8_rte(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(ulong8);
+ulong8 __ovld __cnfn convert_ulong8(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_sat(ulong8);
+ulong8 __ovld __cnfn convert_ulong8_rte(float8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(float8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(float8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(float8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(float8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(float8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(float8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(float8);
+ulong8 __ovld __cnfn convert_ulong8(float8);
+ulong8 __ovld __cnfn convert_ulong8_sat(float8);
+float8 __ovld __cnfn convert_float8_rte(char8);
+float8 __ovld __cnfn convert_float8_rtz(char8);
+float8 __ovld __cnfn convert_float8_rtp(char8);
+float8 __ovld __cnfn convert_float8_rtn(char8);
+float8 __ovld __cnfn convert_float8(char8);
+float8 __ovld __cnfn convert_float8_rte(uchar8);
+float8 __ovld __cnfn convert_float8_rtz(uchar8);
+float8 __ovld __cnfn convert_float8_rtp(uchar8);
+float8 __ovld __cnfn convert_float8_rtn(uchar8);
+float8 __ovld __cnfn convert_float8(uchar8);
+float8 __ovld __cnfn convert_float8_rte(short8);
+float8 __ovld __cnfn convert_float8_rtz(short8);
+float8 __ovld __cnfn convert_float8_rtp(short8);
+float8 __ovld __cnfn convert_float8_rtn(short8);
+float8 __ovld __cnfn convert_float8(short8);
+float8 __ovld __cnfn convert_float8_rte(ushort8);
+float8 __ovld __cnfn convert_float8_rtz(ushort8);
+float8 __ovld __cnfn convert_float8_rtp(ushort8);
+float8 __ovld __cnfn convert_float8_rtn(ushort8);
+float8 __ovld __cnfn convert_float8(ushort8);
+float8 __ovld __cnfn convert_float8_rte(int8);
+float8 __ovld __cnfn convert_float8_rtz(int8);
+float8 __ovld __cnfn convert_float8_rtp(int8);
+float8 __ovld __cnfn convert_float8_rtn(int8);
+float8 __ovld __cnfn convert_float8(int8);
+float8 __ovld __cnfn convert_float8_rte(uint8);
+float8 __ovld __cnfn convert_float8_rtz(uint8);
+float8 __ovld __cnfn convert_float8_rtp(uint8);
+float8 __ovld __cnfn convert_float8_rtn(uint8);
+float8 __ovld __cnfn convert_float8(uint8);
+float8 __ovld __cnfn convert_float8_rte(long8);
+float8 __ovld __cnfn convert_float8_rtz(long8);
+float8 __ovld __cnfn convert_float8_rtp(long8);
+float8 __ovld __cnfn convert_float8_rtn(long8);
+float8 __ovld __cnfn convert_float8(long8);
+float8 __ovld __cnfn convert_float8_rte(ulong8);
+float8 __ovld __cnfn convert_float8_rtz(ulong8);
+float8 __ovld __cnfn convert_float8_rtp(ulong8);
+float8 __ovld __cnfn convert_float8_rtn(ulong8);
+float8 __ovld __cnfn convert_float8(ulong8);
+float8 __ovld __cnfn convert_float8_rte(float8);
+float8 __ovld __cnfn convert_float8_rtz(float8);
+float8 __ovld __cnfn convert_float8_rtp(float8);
+float8 __ovld __cnfn convert_float8_rtn(float8);
+float8 __ovld __cnfn convert_float8(float8);
+char16 __ovld __cnfn convert_char16_rte(char16);
+char16 __ovld __cnfn convert_char16_sat_rte(char16);
+char16 __ovld __cnfn convert_char16_rtz(char16);
+char16 __ovld __cnfn convert_char16_sat_rtz(char16);
+char16 __ovld __cnfn convert_char16_rtp(char16);
+char16 __ovld __cnfn convert_char16_sat_rtp(char16);
+char16 __ovld __cnfn convert_char16_rtn(char16);
+char16 __ovld __cnfn convert_char16_sat_rtn(char16);
+char16 __ovld __cnfn convert_char16(char16);
+char16 __ovld __cnfn convert_char16_sat(char16);
+char16 __ovld __cnfn convert_char16_rte(uchar16);
+char16 __ovld __cnfn convert_char16_sat_rte(uchar16);
+char16 __ovld __cnfn convert_char16_rtz(uchar16);
+char16 __ovld __cnfn convert_char16_sat_rtz(uchar16);
+char16 __ovld __cnfn convert_char16_rtp(uchar16);
+char16 __ovld __cnfn convert_char16_sat_rtp(uchar16);
+char16 __ovld __cnfn convert_char16_rtn(uchar16);
+char16 __ovld __cnfn convert_char16_sat_rtn(uchar16);
+char16 __ovld __cnfn convert_char16(uchar16);
+char16 __ovld __cnfn convert_char16_sat(uchar16);
+char16 __ovld __cnfn convert_char16_rte(short16);
+char16 __ovld __cnfn convert_char16_sat_rte(short16);
+char16 __ovld __cnfn convert_char16_rtz(short16);
+char16 __ovld __cnfn convert_char16_sat_rtz(short16);
+char16 __ovld __cnfn convert_char16_rtp(short16);
+char16 __ovld __cnfn convert_char16_sat_rtp(short16);
+char16 __ovld __cnfn convert_char16_rtn(short16);
+char16 __ovld __cnfn convert_char16_sat_rtn(short16);
+char16 __ovld __cnfn convert_char16(short16);
+char16 __ovld __cnfn convert_char16_sat(short16);
+char16 __ovld __cnfn convert_char16_rte(ushort16);
+char16 __ovld __cnfn convert_char16_sat_rte(ushort16);
+char16 __ovld __cnfn convert_char16_rtz(ushort16);
+char16 __ovld __cnfn convert_char16_sat_rtz(ushort16);
+char16 __ovld __cnfn convert_char16_rtp(ushort16);
+char16 __ovld __cnfn convert_char16_sat_rtp(ushort16);
+char16 __ovld __cnfn convert_char16_rtn(ushort16);
+char16 __ovld __cnfn convert_char16_sat_rtn(ushort16);
+char16 __ovld __cnfn convert_char16(ushort16);
+char16 __ovld __cnfn convert_char16_sat(ushort16);
+char16 __ovld __cnfn convert_char16_rte(int16);
+char16 __ovld __cnfn convert_char16_sat_rte(int16);
+char16 __ovld __cnfn convert_char16_rtz(int16);
+char16 __ovld __cnfn convert_char16_sat_rtz(int16);
+char16 __ovld __cnfn convert_char16_rtp(int16);
+char16 __ovld __cnfn convert_char16_sat_rtp(int16);
+char16 __ovld __cnfn convert_char16_rtn(int16);
+char16 __ovld __cnfn convert_char16_sat_rtn(int16);
+char16 __ovld __cnfn convert_char16(int16);
+char16 __ovld __cnfn convert_char16_sat(int16);
+char16 __ovld __cnfn convert_char16_rte(uint16);
+char16 __ovld __cnfn convert_char16_sat_rte(uint16);
+char16 __ovld __cnfn convert_char16_rtz(uint16);
+char16 __ovld __cnfn convert_char16_sat_rtz(uint16);
+char16 __ovld __cnfn convert_char16_rtp(uint16);
+char16 __ovld __cnfn convert_char16_sat_rtp(uint16);
+char16 __ovld __cnfn convert_char16_rtn(uint16);
+char16 __ovld __cnfn convert_char16_sat_rtn(uint16);
+char16 __ovld __cnfn convert_char16(uint16);
+char16 __ovld __cnfn convert_char16_sat(uint16);
+char16 __ovld __cnfn convert_char16_rte(long16);
+char16 __ovld __cnfn convert_char16_sat_rte(long16);
+char16 __ovld __cnfn convert_char16_rtz(long16);
+char16 __ovld __cnfn convert_char16_sat_rtz(long16);
+char16 __ovld __cnfn convert_char16_rtp(long16);
+char16 __ovld __cnfn convert_char16_sat_rtp(long16);
+char16 __ovld __cnfn convert_char16_rtn(long16);
+char16 __ovld __cnfn convert_char16_sat_rtn(long16);
+char16 __ovld __cnfn convert_char16(long16);
+char16 __ovld __cnfn convert_char16_sat(long16);
+char16 __ovld __cnfn convert_char16_rte(ulong16);
+char16 __ovld __cnfn convert_char16_sat_rte(ulong16);
+char16 __ovld __cnfn convert_char16_rtz(ulong16);
+char16 __ovld __cnfn convert_char16_sat_rtz(ulong16);
+char16 __ovld __cnfn convert_char16_rtp(ulong16);
+char16 __ovld __cnfn convert_char16_sat_rtp(ulong16);
+char16 __ovld __cnfn convert_char16_rtn(ulong16);
+char16 __ovld __cnfn convert_char16_sat_rtn(ulong16);
+char16 __ovld __cnfn convert_char16(ulong16);
+char16 __ovld __cnfn convert_char16_sat(ulong16);
+char16 __ovld __cnfn convert_char16_rte(float16);
+char16 __ovld __cnfn convert_char16_sat_rte(float16);
+char16 __ovld __cnfn convert_char16_rtz(float16);
+char16 __ovld __cnfn convert_char16_sat_rtz(float16);
+char16 __ovld __cnfn convert_char16_rtp(float16);
+char16 __ovld __cnfn convert_char16_sat_rtp(float16);
+char16 __ovld __cnfn convert_char16_rtn(float16);
+char16 __ovld __cnfn convert_char16_sat_rtn(float16);
+char16 __ovld __cnfn convert_char16(float16);
+char16 __ovld __cnfn convert_char16_sat(float16);
+uchar16 __ovld __cnfn convert_uchar16_rte(char16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(char16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(char16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(char16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(char16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(char16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(char16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(char16);
+uchar16 __ovld __cnfn convert_uchar16(char16);
+uchar16 __ovld __cnfn convert_uchar16_sat(char16);
+uchar16 __ovld __cnfn convert_uchar16_rte(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(uchar16);
+uchar16 __ovld __cnfn convert_uchar16(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_sat(uchar16);
+uchar16 __ovld __cnfn convert_uchar16_rte(short16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(short16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(short16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(short16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(short16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(short16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(short16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(short16);
+uchar16 __ovld __cnfn convert_uchar16(short16);
+uchar16 __ovld __cnfn convert_uchar16_sat(short16);
+uchar16 __ovld __cnfn convert_uchar16_rte(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(ushort16);
+uchar16 __ovld __cnfn convert_uchar16(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_sat(ushort16);
+uchar16 __ovld __cnfn convert_uchar16_rte(int16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(int16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(int16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(int16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(int16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(int16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(int16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(int16);
+uchar16 __ovld __cnfn convert_uchar16(int16);
+uchar16 __ovld __cnfn convert_uchar16_sat(int16);
+uchar16 __ovld __cnfn convert_uchar16_rte(uint16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(uint16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(uint16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(uint16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(uint16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(uint16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(uint16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(uint16);
+uchar16 __ovld __cnfn convert_uchar16(uint16);
+uchar16 __ovld __cnfn convert_uchar16_sat(uint16);
+uchar16 __ovld __cnfn convert_uchar16_rte(long16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(long16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(long16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(long16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(long16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(long16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(long16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(long16);
+uchar16 __ovld __cnfn convert_uchar16(long16);
+uchar16 __ovld __cnfn convert_uchar16_sat(long16);
+uchar16 __ovld __cnfn convert_uchar16_rte(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(ulong16);
+uchar16 __ovld __cnfn convert_uchar16(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_sat(ulong16);
+uchar16 __ovld __cnfn convert_uchar16_rte(float16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(float16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(float16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(float16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(float16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(float16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(float16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(float16);
+uchar16 __ovld __cnfn convert_uchar16(float16);
+uchar16 __ovld __cnfn convert_uchar16_sat(float16);
+short16 __ovld __cnfn convert_short16_rte(char16);
+short16 __ovld __cnfn convert_short16_sat_rte(char16);
+short16 __ovld __cnfn convert_short16_rtz(char16);
+short16 __ovld __cnfn convert_short16_sat_rtz(char16);
+short16 __ovld __cnfn convert_short16_rtp(char16);
+short16 __ovld __cnfn convert_short16_sat_rtp(char16);
+short16 __ovld __cnfn convert_short16_rtn(char16);
+short16 __ovld __cnfn convert_short16_sat_rtn(char16);
+short16 __ovld __cnfn convert_short16(char16);
+short16 __ovld __cnfn convert_short16_sat(char16);
+short16 __ovld __cnfn convert_short16_rte(uchar16);
+short16 __ovld __cnfn convert_short16_sat_rte(uchar16);
+short16 __ovld __cnfn convert_short16_rtz(uchar16);
+short16 __ovld __cnfn convert_short16_sat_rtz(uchar16);
+short16 __ovld __cnfn convert_short16_rtp(uchar16);
+short16 __ovld __cnfn convert_short16_sat_rtp(uchar16);
+short16 __ovld __cnfn convert_short16_rtn(uchar16);
+short16 __ovld __cnfn convert_short16_sat_rtn(uchar16);
+short16 __ovld __cnfn convert_short16(uchar16);
+short16 __ovld __cnfn convert_short16_sat(uchar16);
+short16 __ovld __cnfn convert_short16_rte(short16);
+short16 __ovld __cnfn convert_short16_sat_rte(short16);
+short16 __ovld __cnfn convert_short16_rtz(short16);
+short16 __ovld __cnfn convert_short16_sat_rtz(short16);
+short16 __ovld __cnfn convert_short16_rtp(short16);
+short16 __ovld __cnfn convert_short16_sat_rtp(short16);
+short16 __ovld __cnfn convert_short16_rtn(short16);
+short16 __ovld __cnfn convert_short16_sat_rtn(short16);
+short16 __ovld __cnfn convert_short16(short16);
+short16 __ovld __cnfn convert_short16_sat(short16);
+short16 __ovld __cnfn convert_short16_rte(ushort16);
+short16 __ovld __cnfn convert_short16_sat_rte(ushort16);
+short16 __ovld __cnfn convert_short16_rtz(ushort16);
+short16 __ovld __cnfn convert_short16_sat_rtz(ushort16);
+short16 __ovld __cnfn convert_short16_rtp(ushort16);
+short16 __ovld __cnfn convert_short16_sat_rtp(ushort16);
+short16 __ovld __cnfn convert_short16_rtn(ushort16);
+short16 __ovld __cnfn convert_short16_sat_rtn(ushort16);
+short16 __ovld __cnfn convert_short16(ushort16);
+short16 __ovld __cnfn convert_short16_sat(ushort16);
+short16 __ovld __cnfn convert_short16_rte(int16);
+short16 __ovld __cnfn convert_short16_sat_rte(int16);
+short16 __ovld __cnfn convert_short16_rtz(int16);
+short16 __ovld __cnfn convert_short16_sat_rtz(int16);
+short16 __ovld __cnfn convert_short16_rtp(int16);
+short16 __ovld __cnfn convert_short16_sat_rtp(int16);
+short16 __ovld __cnfn convert_short16_rtn(int16);
+short16 __ovld __cnfn convert_short16_sat_rtn(int16);
+short16 __ovld __cnfn convert_short16(int16);
+short16 __ovld __cnfn convert_short16_sat(int16);
+short16 __ovld __cnfn convert_short16_rte(uint16);
+short16 __ovld __cnfn convert_short16_sat_rte(uint16);
+short16 __ovld __cnfn convert_short16_rtz(uint16);
+short16 __ovld __cnfn convert_short16_sat_rtz(uint16);
+short16 __ovld __cnfn convert_short16_rtp(uint16);
+short16 __ovld __cnfn convert_short16_sat_rtp(uint16);
+short16 __ovld __cnfn convert_short16_rtn(uint16);
+short16 __ovld __cnfn convert_short16_sat_rtn(uint16);
+short16 __ovld __cnfn convert_short16(uint16);
+short16 __ovld __cnfn convert_short16_sat(uint16);
+short16 __ovld __cnfn convert_short16_rte(long16);
+short16 __ovld __cnfn convert_short16_sat_rte(long16);
+short16 __ovld __cnfn convert_short16_rtz(long16);
+short16 __ovld __cnfn convert_short16_sat_rtz(long16);
+short16 __ovld __cnfn convert_short16_rtp(long16);
+short16 __ovld __cnfn convert_short16_sat_rtp(long16);
+short16 __ovld __cnfn convert_short16_rtn(long16);
+short16 __ovld __cnfn convert_short16_sat_rtn(long16);
+short16 __ovld __cnfn convert_short16(long16);
+short16 __ovld __cnfn convert_short16_sat(long16);
+short16 __ovld __cnfn convert_short16_rte(ulong16);
+short16 __ovld __cnfn convert_short16_sat_rte(ulong16);
+short16 __ovld __cnfn convert_short16_rtz(ulong16);
+short16 __ovld __cnfn convert_short16_sat_rtz(ulong16);
+short16 __ovld __cnfn convert_short16_rtp(ulong16);
+short16 __ovld __cnfn convert_short16_sat_rtp(ulong16);
+short16 __ovld __cnfn convert_short16_rtn(ulong16);
+short16 __ovld __cnfn convert_short16_sat_rtn(ulong16);
+short16 __ovld __cnfn convert_short16(ulong16);
+short16 __ovld __cnfn convert_short16_sat(ulong16);
+short16 __ovld __cnfn convert_short16_rte(float16);
+short16 __ovld __cnfn convert_short16_sat_rte(float16);
+short16 __ovld __cnfn convert_short16_rtz(float16);
+short16 __ovld __cnfn convert_short16_sat_rtz(float16);
+short16 __ovld __cnfn convert_short16_rtp(float16);
+short16 __ovld __cnfn convert_short16_sat_rtp(float16);
+short16 __ovld __cnfn convert_short16_rtn(float16);
+short16 __ovld __cnfn convert_short16_sat_rtn(float16);
+short16 __ovld __cnfn convert_short16(float16);
+short16 __ovld __cnfn convert_short16_sat(float16);
+ushort16 __ovld __cnfn convert_ushort16_rte(char16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(char16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(char16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(char16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(char16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(char16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(char16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(char16);
+ushort16 __ovld __cnfn convert_ushort16(char16);
+ushort16 __ovld __cnfn convert_ushort16_sat(char16);
+ushort16 __ovld __cnfn convert_ushort16_rte(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(uchar16);
+ushort16 __ovld __cnfn convert_ushort16(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_sat(uchar16);
+ushort16 __ovld __cnfn convert_ushort16_rte(short16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(short16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(short16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(short16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(short16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(short16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(short16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(short16);
+ushort16 __ovld __cnfn convert_ushort16(short16);
+ushort16 __ovld __cnfn convert_ushort16_sat(short16);
+ushort16 __ovld __cnfn convert_ushort16_rte(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(ushort16);
+ushort16 __ovld __cnfn convert_ushort16(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_sat(ushort16);
+ushort16 __ovld __cnfn convert_ushort16_rte(int16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(int16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(int16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(int16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(int16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(int16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(int16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(int16);
+ushort16 __ovld __cnfn convert_ushort16(int16);
+ushort16 __ovld __cnfn convert_ushort16_sat(int16);
+ushort16 __ovld __cnfn convert_ushort16_rte(uint16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(uint16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(uint16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(uint16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(uint16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(uint16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(uint16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(uint16);
+ushort16 __ovld __cnfn convert_ushort16(uint16);
+ushort16 __ovld __cnfn convert_ushort16_sat(uint16);
+ushort16 __ovld __cnfn convert_ushort16_rte(long16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(long16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(long16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(long16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(long16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(long16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(long16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(long16);
+ushort16 __ovld __cnfn convert_ushort16(long16);
+ushort16 __ovld __cnfn convert_ushort16_sat(long16);
+ushort16 __ovld __cnfn convert_ushort16_rte(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(ulong16);
+ushort16 __ovld __cnfn convert_ushort16(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_sat(ulong16);
+ushort16 __ovld __cnfn convert_ushort16_rte(float16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(float16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(float16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(float16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(float16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(float16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(float16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(float16);
+ushort16 __ovld __cnfn convert_ushort16(float16);
+ushort16 __ovld __cnfn convert_ushort16_sat(float16);
+int16 __ovld __cnfn convert_int16_rte(char16);
+int16 __ovld __cnfn convert_int16_sat_rte(char16);
+int16 __ovld __cnfn convert_int16_rtz(char16);
+int16 __ovld __cnfn convert_int16_sat_rtz(char16);
+int16 __ovld __cnfn convert_int16_rtp(char16);
+int16 __ovld __cnfn convert_int16_sat_rtp(char16);
+int16 __ovld __cnfn convert_int16_rtn(char16);
+int16 __ovld __cnfn convert_int16_sat_rtn(char16);
+int16 __ovld __cnfn convert_int16(char16);
+int16 __ovld __cnfn convert_int16_sat(char16);
+int16 __ovld __cnfn convert_int16_rte(uchar16);
+int16 __ovld __cnfn convert_int16_sat_rte(uchar16);
+int16 __ovld __cnfn convert_int16_rtz(uchar16);
+int16 __ovld __cnfn convert_int16_sat_rtz(uchar16);
+int16 __ovld __cnfn convert_int16_rtp(uchar16);
+int16 __ovld __cnfn convert_int16_sat_rtp(uchar16);
+int16 __ovld __cnfn convert_int16_rtn(uchar16);
+int16 __ovld __cnfn convert_int16_sat_rtn(uchar16);
+int16 __ovld __cnfn convert_int16(uchar16);
+int16 __ovld __cnfn convert_int16_sat(uchar16);
+int16 __ovld __cnfn convert_int16_rte(short16);
+int16 __ovld __cnfn convert_int16_sat_rte(short16);
+int16 __ovld __cnfn convert_int16_rtz(short16);
+int16 __ovld __cnfn convert_int16_sat_rtz(short16);
+int16 __ovld __cnfn convert_int16_rtp(short16);
+int16 __ovld __cnfn convert_int16_sat_rtp(short16);
+int16 __ovld __cnfn convert_int16_rtn(short16);
+int16 __ovld __cnfn convert_int16_sat_rtn(short16);
+int16 __ovld __cnfn convert_int16(short16);
+int16 __ovld __cnfn convert_int16_sat(short16);
+int16 __ovld __cnfn convert_int16_rte(ushort16);
+int16 __ovld __cnfn convert_int16_sat_rte(ushort16);
+int16 __ovld __cnfn convert_int16_rtz(ushort16);
+int16 __ovld __cnfn convert_int16_sat_rtz(ushort16);
+int16 __ovld __cnfn convert_int16_rtp(ushort16);
+int16 __ovld __cnfn convert_int16_sat_rtp(ushort16);
+int16 __ovld __cnfn convert_int16_rtn(ushort16);
+int16 __ovld __cnfn convert_int16_sat_rtn(ushort16);
+int16 __ovld __cnfn convert_int16(ushort16);
+int16 __ovld __cnfn convert_int16_sat(ushort16);
+int16 __ovld __cnfn convert_int16_rte(int16);
+int16 __ovld __cnfn convert_int16_sat_rte(int16);
+int16 __ovld __cnfn convert_int16_rtz(int16);
+int16 __ovld __cnfn convert_int16_sat_rtz(int16);
+int16 __ovld __cnfn convert_int16_rtp(int16);
+int16 __ovld __cnfn convert_int16_sat_rtp(int16);
+int16 __ovld __cnfn convert_int16_rtn(int16);
+int16 __ovld __cnfn convert_int16_sat_rtn(int16);
+int16 __ovld __cnfn convert_int16(int16);
+int16 __ovld __cnfn convert_int16_sat(int16);
+int16 __ovld __cnfn convert_int16_rte(uint16);
+int16 __ovld __cnfn convert_int16_sat_rte(uint16);
+int16 __ovld __cnfn convert_int16_rtz(uint16);
+int16 __ovld __cnfn convert_int16_sat_rtz(uint16);
+int16 __ovld __cnfn convert_int16_rtp(uint16);
+int16 __ovld __cnfn convert_int16_sat_rtp(uint16);
+int16 __ovld __cnfn convert_int16_rtn(uint16);
+int16 __ovld __cnfn convert_int16_sat_rtn(uint16);
+int16 __ovld __cnfn convert_int16(uint16);
+int16 __ovld __cnfn convert_int16_sat(uint16);
+int16 __ovld __cnfn convert_int16_rte(long16);
+int16 __ovld __cnfn convert_int16_sat_rte(long16);
+int16 __ovld __cnfn convert_int16_rtz(long16);
+int16 __ovld __cnfn convert_int16_sat_rtz(long16);
+int16 __ovld __cnfn convert_int16_rtp(long16);
+int16 __ovld __cnfn convert_int16_sat_rtp(long16);
+int16 __ovld __cnfn convert_int16_rtn(long16);
+int16 __ovld __cnfn convert_int16_sat_rtn(long16);
+int16 __ovld __cnfn convert_int16(long16);
+int16 __ovld __cnfn convert_int16_sat(long16);
+int16 __ovld __cnfn convert_int16_rte(ulong16);
+int16 __ovld __cnfn convert_int16_sat_rte(ulong16);
+int16 __ovld __cnfn convert_int16_rtz(ulong16);
+int16 __ovld __cnfn convert_int16_sat_rtz(ulong16);
+int16 __ovld __cnfn convert_int16_rtp(ulong16);
+int16 __ovld __cnfn convert_int16_sat_rtp(ulong16);
+int16 __ovld __cnfn convert_int16_rtn(ulong16);
+int16 __ovld __cnfn convert_int16_sat_rtn(ulong16);
+int16 __ovld __cnfn convert_int16(ulong16);
+int16 __ovld __cnfn convert_int16_sat(ulong16);
+int16 __ovld __cnfn convert_int16_rte(float16);
+int16 __ovld __cnfn convert_int16_sat_rte(float16);
+int16 __ovld __cnfn convert_int16_rtz(float16);
+int16 __ovld __cnfn convert_int16_sat_rtz(float16);
+int16 __ovld __cnfn convert_int16_rtp(float16);
+int16 __ovld __cnfn convert_int16_sat_rtp(float16);
+int16 __ovld __cnfn convert_int16_rtn(float16);
+int16 __ovld __cnfn convert_int16_sat_rtn(float16);
+int16 __ovld __cnfn convert_int16(float16);
+int16 __ovld __cnfn convert_int16_sat(float16);
+uint16 __ovld __cnfn convert_uint16_rte(char16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(char16);
+uint16 __ovld __cnfn convert_uint16_rtz(char16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(char16);
+uint16 __ovld __cnfn convert_uint16_rtp(char16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(char16);
+uint16 __ovld __cnfn convert_uint16_rtn(char16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(char16);
+uint16 __ovld __cnfn convert_uint16(char16);
+uint16 __ovld __cnfn convert_uint16_sat(char16);
+uint16 __ovld __cnfn convert_uint16_rte(uchar16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(uchar16);
+uint16 __ovld __cnfn convert_uint16_rtz(uchar16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(uchar16);
+uint16 __ovld __cnfn convert_uint16_rtp(uchar16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(uchar16);
+uint16 __ovld __cnfn convert_uint16_rtn(uchar16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(uchar16);
+uint16 __ovld __cnfn convert_uint16(uchar16);
+uint16 __ovld __cnfn convert_uint16_sat(uchar16);
+uint16 __ovld __cnfn convert_uint16_rte(short16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(short16);
+uint16 __ovld __cnfn convert_uint16_rtz(short16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(short16);
+uint16 __ovld __cnfn convert_uint16_rtp(short16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(short16);
+uint16 __ovld __cnfn convert_uint16_rtn(short16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(short16);
+uint16 __ovld __cnfn convert_uint16(short16);
+uint16 __ovld __cnfn convert_uint16_sat(short16);
+uint16 __ovld __cnfn convert_uint16_rte(ushort16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(ushort16);
+uint16 __ovld __cnfn convert_uint16_rtz(ushort16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(ushort16);
+uint16 __ovld __cnfn convert_uint16_rtp(ushort16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(ushort16);
+uint16 __ovld __cnfn convert_uint16_rtn(ushort16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(ushort16);
+uint16 __ovld __cnfn convert_uint16(ushort16);
+uint16 __ovld __cnfn convert_uint16_sat(ushort16);
+uint16 __ovld __cnfn convert_uint16_rte(int16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(int16);
+uint16 __ovld __cnfn convert_uint16_rtz(int16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(int16);
+uint16 __ovld __cnfn convert_uint16_rtp(int16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(int16);
+uint16 __ovld __cnfn convert_uint16_rtn(int16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(int16);
+uint16 __ovld __cnfn convert_uint16(int16);
+uint16 __ovld __cnfn convert_uint16_sat(int16);
+uint16 __ovld __cnfn convert_uint16_rte(uint16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(uint16);
+uint16 __ovld __cnfn convert_uint16_rtz(uint16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(uint16);
+uint16 __ovld __cnfn convert_uint16_rtp(uint16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(uint16);
+uint16 __ovld __cnfn convert_uint16_rtn(uint16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(uint16);
+uint16 __ovld __cnfn convert_uint16(uint16);
+uint16 __ovld __cnfn convert_uint16_sat(uint16);
+uint16 __ovld __cnfn convert_uint16_rte(long16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(long16);
+uint16 __ovld __cnfn convert_uint16_rtz(long16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(long16);
+uint16 __ovld __cnfn convert_uint16_rtp(long16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(long16);
+uint16 __ovld __cnfn convert_uint16_rtn(long16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(long16);
+uint16 __ovld __cnfn convert_uint16(long16);
+uint16 __ovld __cnfn convert_uint16_sat(long16);
+uint16 __ovld __cnfn convert_uint16_rte(ulong16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(ulong16);
+uint16 __ovld __cnfn convert_uint16_rtz(ulong16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(ulong16);
+uint16 __ovld __cnfn convert_uint16_rtp(ulong16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(ulong16);
+uint16 __ovld __cnfn convert_uint16_rtn(ulong16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(ulong16);
+uint16 __ovld __cnfn convert_uint16(ulong16);
+uint16 __ovld __cnfn convert_uint16_sat(ulong16);
+uint16 __ovld __cnfn convert_uint16_rte(float16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(float16);
+uint16 __ovld __cnfn convert_uint16_rtz(float16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(float16);
+uint16 __ovld __cnfn convert_uint16_rtp(float16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(float16);
+uint16 __ovld __cnfn convert_uint16_rtn(float16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(float16);
+uint16 __ovld __cnfn convert_uint16(float16);
+uint16 __ovld __cnfn convert_uint16_sat(float16);
+long16 __ovld __cnfn convert_long16_rte(char16);
+long16 __ovld __cnfn convert_long16_sat_rte(char16);
+long16 __ovld __cnfn convert_long16_rtz(char16);
+long16 __ovld __cnfn convert_long16_sat_rtz(char16);
+long16 __ovld __cnfn convert_long16_rtp(char16);
+long16 __ovld __cnfn convert_long16_sat_rtp(char16);
+long16 __ovld __cnfn convert_long16_rtn(char16);
+long16 __ovld __cnfn convert_long16_sat_rtn(char16);
+long16 __ovld __cnfn convert_long16(char16);
+long16 __ovld __cnfn convert_long16_sat(char16);
+long16 __ovld __cnfn convert_long16_rte(uchar16);
+long16 __ovld __cnfn convert_long16_sat_rte(uchar16);
+long16 __ovld __cnfn convert_long16_rtz(uchar16);
+long16 __ovld __cnfn convert_long16_sat_rtz(uchar16);
+long16 __ovld __cnfn convert_long16_rtp(uchar16);
+long16 __ovld __cnfn convert_long16_sat_rtp(uchar16);
+long16 __ovld __cnfn convert_long16_rtn(uchar16);
+long16 __ovld __cnfn convert_long16_sat_rtn(uchar16);
+long16 __ovld __cnfn convert_long16(uchar16);
+long16 __ovld __cnfn convert_long16_sat(uchar16);
+long16 __ovld __cnfn convert_long16_rte(short16);
+long16 __ovld __cnfn convert_long16_sat_rte(short16);
+long16 __ovld __cnfn convert_long16_rtz(short16);
+long16 __ovld __cnfn convert_long16_sat_rtz(short16);
+long16 __ovld __cnfn convert_long16_rtp(short16);
+long16 __ovld __cnfn convert_long16_sat_rtp(short16);
+long16 __ovld __cnfn convert_long16_rtn(short16);
+long16 __ovld __cnfn convert_long16_sat_rtn(short16);
+long16 __ovld __cnfn convert_long16(short16);
+long16 __ovld __cnfn convert_long16_sat(short16);
+long16 __ovld __cnfn convert_long16_rte(ushort16);
+long16 __ovld __cnfn convert_long16_sat_rte(ushort16);
+long16 __ovld __cnfn convert_long16_rtz(ushort16);
+long16 __ovld __cnfn convert_long16_sat_rtz(ushort16);
+long16 __ovld __cnfn convert_long16_rtp(ushort16);
+long16 __ovld __cnfn convert_long16_sat_rtp(ushort16);
+long16 __ovld __cnfn convert_long16_rtn(ushort16);
+long16 __ovld __cnfn convert_long16_sat_rtn(ushort16);
+long16 __ovld __cnfn convert_long16(ushort16);
+long16 __ovld __cnfn convert_long16_sat(ushort16);
+long16 __ovld __cnfn convert_long16_rte(int16);
+long16 __ovld __cnfn convert_long16_sat_rte(int16);
+long16 __ovld __cnfn convert_long16_rtz(int16);
+long16 __ovld __cnfn convert_long16_sat_rtz(int16);
+long16 __ovld __cnfn convert_long16_rtp(int16);
+long16 __ovld __cnfn convert_long16_sat_rtp(int16);
+long16 __ovld __cnfn convert_long16_rtn(int16);
+long16 __ovld __cnfn convert_long16_sat_rtn(int16);
+long16 __ovld __cnfn convert_long16(int16);
+long16 __ovld __cnfn convert_long16_sat(int16);
+long16 __ovld __cnfn convert_long16_rte(uint16);
+long16 __ovld __cnfn convert_long16_sat_rte(uint16);
+long16 __ovld __cnfn convert_long16_rtz(uint16);
+long16 __ovld __cnfn convert_long16_sat_rtz(uint16);
+long16 __ovld __cnfn convert_long16_rtp(uint16);
+long16 __ovld __cnfn convert_long16_sat_rtp(uint16);
+long16 __ovld __cnfn convert_long16_rtn(uint16);
+long16 __ovld __cnfn convert_long16_sat_rtn(uint16);
+long16 __ovld __cnfn convert_long16(uint16);
+long16 __ovld __cnfn convert_long16_sat(uint16);
+long16 __ovld __cnfn convert_long16_rte(long16);
+long16 __ovld __cnfn convert_long16_sat_rte(long16);
+long16 __ovld __cnfn convert_long16_rtz(long16);
+long16 __ovld __cnfn convert_long16_sat_rtz(long16);
+long16 __ovld __cnfn convert_long16_rtp(long16);
+long16 __ovld __cnfn convert_long16_sat_rtp(long16);
+long16 __ovld __cnfn convert_long16_rtn(long16);
+long16 __ovld __cnfn convert_long16_sat_rtn(long16);
+long16 __ovld __cnfn convert_long16(long16);
+long16 __ovld __cnfn convert_long16_sat(long16);
+long16 __ovld __cnfn convert_long16_rte(ulong16);
+long16 __ovld __cnfn convert_long16_sat_rte(ulong16);
+long16 __ovld __cnfn convert_long16_rtz(ulong16);
+long16 __ovld __cnfn convert_long16_sat_rtz(ulong16);
+long16 __ovld __cnfn convert_long16_rtp(ulong16);
+long16 __ovld __cnfn convert_long16_sat_rtp(ulong16);
+long16 __ovld __cnfn convert_long16_rtn(ulong16);
+long16 __ovld __cnfn convert_long16_sat_rtn(ulong16);
+long16 __ovld __cnfn convert_long16(ulong16);
+long16 __ovld __cnfn convert_long16_sat(ulong16);
+long16 __ovld __cnfn convert_long16_rte(float16);
+long16 __ovld __cnfn convert_long16_sat_rte(float16);
+long16 __ovld __cnfn convert_long16_rtz(float16);
+long16 __ovld __cnfn convert_long16_sat_rtz(float16);
+long16 __ovld __cnfn convert_long16_rtp(float16);
+long16 __ovld __cnfn convert_long16_sat_rtp(float16);
+long16 __ovld __cnfn convert_long16_rtn(float16);
+long16 __ovld __cnfn convert_long16_sat_rtn(float16);
+long16 __ovld __cnfn convert_long16(float16);
+long16 __ovld __cnfn convert_long16_sat(float16);
+ulong16 __ovld __cnfn convert_ulong16_rte(char16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(char16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(char16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(char16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(char16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(char16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(char16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(char16);
+ulong16 __ovld __cnfn convert_ulong16(char16);
+ulong16 __ovld __cnfn convert_ulong16_sat(char16);
+ulong16 __ovld __cnfn convert_ulong16_rte(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(uchar16);
+ulong16 __ovld __cnfn convert_ulong16(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_sat(uchar16);
+ulong16 __ovld __cnfn convert_ulong16_rte(short16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(short16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(short16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(short16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(short16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(short16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(short16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(short16);
+ulong16 __ovld __cnfn convert_ulong16(short16);
+ulong16 __ovld __cnfn convert_ulong16_sat(short16);
+ulong16 __ovld __cnfn convert_ulong16_rte(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(ushort16);
+ulong16 __ovld __cnfn convert_ulong16(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_sat(ushort16);
+ulong16 __ovld __cnfn convert_ulong16_rte(int16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(int16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(int16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(int16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(int16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(int16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(int16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(int16);
+ulong16 __ovld __cnfn convert_ulong16(int16);
+ulong16 __ovld __cnfn convert_ulong16_sat(int16);
+ulong16 __ovld __cnfn convert_ulong16_rte(uint16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(uint16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(uint16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(uint16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(uint16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(uint16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(uint16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(uint16);
+ulong16 __ovld __cnfn convert_ulong16(uint16);
+ulong16 __ovld __cnfn convert_ulong16_sat(uint16);
+ulong16 __ovld __cnfn convert_ulong16_rte(long16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(long16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(long16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(long16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(long16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(long16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(long16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(long16);
+ulong16 __ovld __cnfn convert_ulong16(long16);
+ulong16 __ovld __cnfn convert_ulong16_sat(long16);
+ulong16 __ovld __cnfn convert_ulong16_rte(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(ulong16);
+ulong16 __ovld __cnfn convert_ulong16(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_sat(ulong16);
+ulong16 __ovld __cnfn convert_ulong16_rte(float16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(float16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(float16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(float16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(float16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(float16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(float16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(float16);
+ulong16 __ovld __cnfn convert_ulong16(float16);
+ulong16 __ovld __cnfn convert_ulong16_sat(float16);
+float16 __ovld __cnfn convert_float16_rte(char16);
+float16 __ovld __cnfn convert_float16_rtz(char16);
+float16 __ovld __cnfn convert_float16_rtp(char16);
+float16 __ovld __cnfn convert_float16_rtn(char16);
+float16 __ovld __cnfn convert_float16(char16);
+float16 __ovld __cnfn convert_float16_rte(uchar16);
+float16 __ovld __cnfn convert_float16_rtz(uchar16);
+float16 __ovld __cnfn convert_float16_rtp(uchar16);
+float16 __ovld __cnfn convert_float16_rtn(uchar16);
+float16 __ovld __cnfn convert_float16(uchar16);
+float16 __ovld __cnfn convert_float16_rte(short16);
+float16 __ovld __cnfn convert_float16_rtz(short16);
+float16 __ovld __cnfn convert_float16_rtp(short16);
+float16 __ovld __cnfn convert_float16_rtn(short16);
+float16 __ovld __cnfn convert_float16(short16);
+float16 __ovld __cnfn convert_float16_rte(ushort16);
+float16 __ovld __cnfn convert_float16_rtz(ushort16);
+float16 __ovld __cnfn convert_float16_rtp(ushort16);
+float16 __ovld __cnfn convert_float16_rtn(ushort16);
+float16 __ovld __cnfn convert_float16(ushort16);
+float16 __ovld __cnfn convert_float16_rte(int16);
+float16 __ovld __cnfn convert_float16_rtz(int16);
+float16 __ovld __cnfn convert_float16_rtp(int16);
+float16 __ovld __cnfn convert_float16_rtn(int16);
+float16 __ovld __cnfn convert_float16(int16);
+float16 __ovld __cnfn convert_float16_rte(uint16);
+float16 __ovld __cnfn convert_float16_rtz(uint16);
+float16 __ovld __cnfn convert_float16_rtp(uint16);
+float16 __ovld __cnfn convert_float16_rtn(uint16);
+float16 __ovld __cnfn convert_float16(uint16);
+float16 __ovld __cnfn convert_float16_rte(long16);
+float16 __ovld __cnfn convert_float16_rtz(long16);
+float16 __ovld __cnfn convert_float16_rtp(long16);
+float16 __ovld __cnfn convert_float16_rtn(long16);
+float16 __ovld __cnfn convert_float16(long16);
+float16 __ovld __cnfn convert_float16_rte(ulong16);
+float16 __ovld __cnfn convert_float16_rtz(ulong16);
+float16 __ovld __cnfn convert_float16_rtp(ulong16);
+float16 __ovld __cnfn convert_float16_rtn(ulong16);
+float16 __ovld __cnfn convert_float16(ulong16);
+float16 __ovld __cnfn convert_float16_rte(float16);
+float16 __ovld __cnfn convert_float16_rtz(float16);
+float16 __ovld __cnfn convert_float16_rtp(float16);
+float16 __ovld __cnfn convert_float16_rtn(float16);
+float16 __ovld __cnfn convert_float16(float16);
+
+// Conversions with double data type parameters or return value.
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+char __ovld __cnfn convert_char(double);
+char __ovld __cnfn convert_char_rte(double);
+char __ovld __cnfn convert_char_rtn(double);
+char __ovld __cnfn convert_char_rtp(double);
+char __ovld __cnfn convert_char_rtz(double);
+char __ovld __cnfn convert_char_sat(double);
+char __ovld __cnfn convert_char_sat_rte(double);
+char __ovld __cnfn convert_char_sat_rtn(double);
+char __ovld __cnfn convert_char_sat_rtp(double);
+char __ovld __cnfn convert_char_sat_rtz(double);
+char2 __ovld __cnfn convert_char2(double2);
+char2 __ovld __cnfn convert_char2_rte(double2);
+char2 __ovld __cnfn convert_char2_rtn(double2);
+char2 __ovld __cnfn convert_char2_rtp(double2);
+char2 __ovld __cnfn convert_char2_rtz(double2);
+char2 __ovld __cnfn convert_char2_sat(double2);
+char2 __ovld __cnfn convert_char2_sat_rte(double2);
+char2 __ovld __cnfn convert_char2_sat_rtn(double2);
+char2 __ovld __cnfn convert_char2_sat_rtp(double2);
+char2 __ovld __cnfn convert_char2_sat_rtz(double2);
+char3 __ovld __cnfn convert_char3(double3);
+char3 __ovld __cnfn convert_char3_rte(double3);
+char3 __ovld __cnfn convert_char3_rtn(double3);
+char3 __ovld __cnfn convert_char3_rtp(double3);
+char3 __ovld __cnfn convert_char3_rtz(double3);
+char3 __ovld __cnfn convert_char3_sat(double3);
+char3 __ovld __cnfn convert_char3_sat_rte(double3);
+char3 __ovld __cnfn convert_char3_sat_rtn(double3);
+char3 __ovld __cnfn convert_char3_sat_rtp(double3);
+char3 __ovld __cnfn convert_char3_sat_rtz(double3);
+char4 __ovld __cnfn convert_char4(double4);
+char4 __ovld __cnfn convert_char4_rte(double4);
+char4 __ovld __cnfn convert_char4_rtn(double4);
+char4 __ovld __cnfn convert_char4_rtp(double4);
+char4 __ovld __cnfn convert_char4_rtz(double4);
+char4 __ovld __cnfn convert_char4_sat(double4);
+char4 __ovld __cnfn convert_char4_sat_rte(double4);
+char4 __ovld __cnfn convert_char4_sat_rtn(double4);
+char4 __ovld __cnfn convert_char4_sat_rtp(double4);
+char4 __ovld __cnfn convert_char4_sat_rtz(double4);
+char8 __ovld __cnfn convert_char8(double8);
+char8 __ovld __cnfn convert_char8_rte(double8);
+char8 __ovld __cnfn convert_char8_rtn(double8);
+char8 __ovld __cnfn convert_char8_rtp(double8);
+char8 __ovld __cnfn convert_char8_rtz(double8);
+char8 __ovld __cnfn convert_char8_sat(double8);
+char8 __ovld __cnfn convert_char8_sat_rte(double8);
+char8 __ovld __cnfn convert_char8_sat_rtn(double8);
+char8 __ovld __cnfn convert_char8_sat_rtp(double8);
+char8 __ovld __cnfn convert_char8_sat_rtz(double8);
+char16 __ovld __cnfn convert_char16(double16);
+char16 __ovld __cnfn convert_char16_rte(double16);
+char16 __ovld __cnfn convert_char16_rtn(double16);
+char16 __ovld __cnfn convert_char16_rtp(double16);
+char16 __ovld __cnfn convert_char16_rtz(double16);
+char16 __ovld __cnfn convert_char16_sat(double16);
+char16 __ovld __cnfn convert_char16_sat_rte(double16);
+char16 __ovld __cnfn convert_char16_sat_rtn(double16);
+char16 __ovld __cnfn convert_char16_sat_rtp(double16);
+char16 __ovld __cnfn convert_char16_sat_rtz(double16);
+
+uchar __ovld __cnfn convert_uchar(double);
+uchar __ovld __cnfn convert_uchar_rte(double);
+uchar __ovld __cnfn convert_uchar_rtn(double);
+uchar __ovld __cnfn convert_uchar_rtp(double);
+uchar __ovld __cnfn convert_uchar_rtz(double);
+uchar __ovld __cnfn convert_uchar_sat(double);
+uchar __ovld __cnfn convert_uchar_sat_rte(double);
+uchar __ovld __cnfn convert_uchar_sat_rtn(double);
+uchar __ovld __cnfn convert_uchar_sat_rtp(double);
+uchar __ovld __cnfn convert_uchar_sat_rtz(double);
+uchar2 __ovld __cnfn convert_uchar2(double2);
+uchar2 __ovld __cnfn convert_uchar2_rte(double2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(double2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(double2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(double2);
+uchar2 __ovld __cnfn convert_uchar2_sat(double2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(double2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(double2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(double2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(double2);
+uchar3 __ovld __cnfn convert_uchar3(double3);
+uchar3 __ovld __cnfn convert_uchar3_rte(double3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(double3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(double3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(double3);
+uchar3 __ovld __cnfn convert_uchar3_sat(double3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(double3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(double3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(double3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(double3);
+uchar4 __ovld __cnfn convert_uchar4(double4);
+uchar4 __ovld __cnfn convert_uchar4_rte(double4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(double4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(double4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(double4);
+uchar4 __ovld __cnfn convert_uchar4_sat(double4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(double4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(double4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(double4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(double4);
+uchar8 __ovld __cnfn convert_uchar8(double8);
+uchar8 __ovld __cnfn convert_uchar8_rte(double8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(double8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(double8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(double8);
+uchar8 __ovld __cnfn convert_uchar8_sat(double8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(double8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(double8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(double8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(double8);
+uchar16 __ovld __cnfn convert_uchar16(double16);
+uchar16 __ovld __cnfn convert_uchar16_rte(double16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(double16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(double16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(double16);
+uchar16 __ovld __cnfn convert_uchar16_sat(double16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(double16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(double16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(double16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(double16);
+
+short __ovld __cnfn convert_short(double);
+short __ovld __cnfn convert_short_rte(double);
+short __ovld __cnfn convert_short_rtn(double);
+short __ovld __cnfn convert_short_rtp(double);
+short __ovld __cnfn convert_short_rtz(double);
+short __ovld __cnfn convert_short_sat(double);
+short __ovld __cnfn convert_short_sat_rte(double);
+short __ovld __cnfn convert_short_sat_rtn(double);
+short __ovld __cnfn convert_short_sat_rtp(double);
+short __ovld __cnfn convert_short_sat_rtz(double);
+short2 __ovld __cnfn convert_short2(double2);
+short2 __ovld __cnfn convert_short2_rte(double2);
+short2 __ovld __cnfn convert_short2_rtn(double2);
+short2 __ovld __cnfn convert_short2_rtp(double2);
+short2 __ovld __cnfn convert_short2_rtz(double2);
+short2 __ovld __cnfn convert_short2_sat(double2);
+short2 __ovld __cnfn convert_short2_sat_rte(double2);
+short2 __ovld __cnfn convert_short2_sat_rtn(double2);
+short2 __ovld __cnfn convert_short2_sat_rtp(double2);
+short2 __ovld __cnfn convert_short2_sat_rtz(double2);
+short3 __ovld __cnfn convert_short3(double3);
+short3 __ovld __cnfn convert_short3_rte(double3);
+short3 __ovld __cnfn convert_short3_rtn(double3);
+short3 __ovld __cnfn convert_short3_rtp(double3);
+short3 __ovld __cnfn convert_short3_rtz(double3);
+short3 __ovld __cnfn convert_short3_sat(double3);
+short3 __ovld __cnfn convert_short3_sat_rte(double3);
+short3 __ovld __cnfn convert_short3_sat_rtn(double3);
+short3 __ovld __cnfn convert_short3_sat_rtp(double3);
+short3 __ovld __cnfn convert_short3_sat_rtz(double3);
+short4 __ovld __cnfn convert_short4(double4);
+short4 __ovld __cnfn convert_short4_rte(double4);
+short4 __ovld __cnfn convert_short4_rtn(double4);
+short4 __ovld __cnfn convert_short4_rtp(double4);
+short4 __ovld __cnfn convert_short4_rtz(double4);
+short4 __ovld __cnfn convert_short4_sat(double4);
+short4 __ovld __cnfn convert_short4_sat_rte(double4);
+short4 __ovld __cnfn convert_short4_sat_rtn(double4);
+short4 __ovld __cnfn convert_short4_sat_rtp(double4);
+short4 __ovld __cnfn convert_short4_sat_rtz(double4);
+short8 __ovld __cnfn convert_short8(double8);
+short8 __ovld __cnfn convert_short8_rte(double8);
+short8 __ovld __cnfn convert_short8_rtn(double8);
+short8 __ovld __cnfn convert_short8_rtp(double8);
+short8 __ovld __cnfn convert_short8_rtz(double8);
+short8 __ovld __cnfn convert_short8_sat(double8);
+short8 __ovld __cnfn convert_short8_sat_rte(double8);
+short8 __ovld __cnfn convert_short8_sat_rtn(double8);
+short8 __ovld __cnfn convert_short8_sat_rtp(double8);
+short8 __ovld __cnfn convert_short8_sat_rtz(double8);
+short16 __ovld __cnfn convert_short16(double16);
+short16 __ovld __cnfn convert_short16_rte(double16);
+short16 __ovld __cnfn convert_short16_rtn(double16);
+short16 __ovld __cnfn convert_short16_rtp(double16);
+short16 __ovld __cnfn convert_short16_rtz(double16);
+short16 __ovld __cnfn convert_short16_sat(double16);
+short16 __ovld __cnfn convert_short16_sat_rte(double16);
+short16 __ovld __cnfn convert_short16_sat_rtn(double16);
+short16 __ovld __cnfn convert_short16_sat_rtp(double16);
+short16 __ovld __cnfn convert_short16_sat_rtz(double16);
+
+ushort __ovld __cnfn convert_ushort(double);
+ushort __ovld __cnfn convert_ushort_rte(double);
+ushort __ovld __cnfn convert_ushort_rtn(double);
+ushort __ovld __cnfn convert_ushort_rtp(double);
+ushort __ovld __cnfn convert_ushort_rtz(double);
+ushort __ovld __cnfn convert_ushort_sat(double);
+ushort __ovld __cnfn convert_ushort_sat_rte(double);
+ushort __ovld __cnfn convert_ushort_sat_rtn(double);
+ushort __ovld __cnfn convert_ushort_sat_rtp(double);
+ushort __ovld __cnfn convert_ushort_sat_rtz(double);
+ushort2 __ovld __cnfn convert_ushort2(double2);
+ushort2 __ovld __cnfn convert_ushort2_rte(double2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(double2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(double2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(double2);
+ushort2 __ovld __cnfn convert_ushort2_sat(double2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(double2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(double2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(double2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(double2);
+ushort3 __ovld __cnfn convert_ushort3(double3);
+ushort3 __ovld __cnfn convert_ushort3_rte(double3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(double3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(double3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(double3);
+ushort3 __ovld __cnfn convert_ushort3_sat(double3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(double3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(double3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(double3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(double3);
+ushort4 __ovld __cnfn convert_ushort4(double4);
+ushort4 __ovld __cnfn convert_ushort4_rte(double4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(double4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(double4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(double4);
+ushort4 __ovld __cnfn convert_ushort4_sat(double4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(double4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(double4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(double4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(double4);
+ushort8 __ovld __cnfn convert_ushort8(double8);
+ushort8 __ovld __cnfn convert_ushort8_rte(double8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(double8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(double8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(double8);
+ushort8 __ovld __cnfn convert_ushort8_sat(double8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(double8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(double8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(double8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(double8);
+ushort16 __ovld __cnfn convert_ushort16(double16);
+ushort16 __ovld __cnfn convert_ushort16_rte(double16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(double16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(double16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(double16);
+ushort16 __ovld __cnfn convert_ushort16_sat(double16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(double16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(double16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(double16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(double16);
+
+int __ovld __cnfn convert_int(double);
+int __ovld __cnfn convert_int_rte(double);
+int __ovld __cnfn convert_int_rtn(double);
+int __ovld __cnfn convert_int_rtp(double);
+int __ovld __cnfn convert_int_rtz(double);
+int __ovld __cnfn convert_int_sat(double);
+int __ovld __cnfn convert_int_sat_rte(double);
+int __ovld __cnfn convert_int_sat_rtn(double);
+int __ovld __cnfn convert_int_sat_rtp(double);
+int __ovld __cnfn convert_int_sat_rtz(double);
+int2 __ovld __cnfn convert_int2(double2);
+int2 __ovld __cnfn convert_int2_rte(double2);
+int2 __ovld __cnfn convert_int2_rtn(double2);
+int2 __ovld __cnfn convert_int2_rtp(double2);
+int2 __ovld __cnfn convert_int2_rtz(double2);
+int2 __ovld __cnfn convert_int2_sat(double2);
+int2 __ovld __cnfn convert_int2_sat_rte(double2);
+int2 __ovld __cnfn convert_int2_sat_rtn(double2);
+int2 __ovld __cnfn convert_int2_sat_rtp(double2);
+int2 __ovld __cnfn convert_int2_sat_rtz(double2);
+int3 __ovld __cnfn convert_int3(double3);
+int3 __ovld __cnfn convert_int3_rte(double3);
+int3 __ovld __cnfn convert_int3_rtn(double3);
+int3 __ovld __cnfn convert_int3_rtp(double3);
+int3 __ovld __cnfn convert_int3_rtz(double3);
+int3 __ovld __cnfn convert_int3_sat(double3);
+int3 __ovld __cnfn convert_int3_sat_rte(double3);
+int3 __ovld __cnfn convert_int3_sat_rtn(double3);
+int3 __ovld __cnfn convert_int3_sat_rtp(double3);
+int3 __ovld __cnfn convert_int3_sat_rtz(double3);
+int4 __ovld __cnfn convert_int4(double4);
+int4 __ovld __cnfn convert_int4_rte(double4);
+int4 __ovld __cnfn convert_int4_rtn(double4);
+int4 __ovld __cnfn convert_int4_rtp(double4);
+int4 __ovld __cnfn convert_int4_rtz(double4);
+int4 __ovld __cnfn convert_int4_sat(double4);
+int4 __ovld __cnfn convert_int4_sat_rte(double4);
+int4 __ovld __cnfn convert_int4_sat_rtn(double4);
+int4 __ovld __cnfn convert_int4_sat_rtp(double4);
+int4 __ovld __cnfn convert_int4_sat_rtz(double4);
+int8 __ovld __cnfn convert_int8(double8);
+int8 __ovld __cnfn convert_int8_rte(double8);
+int8 __ovld __cnfn convert_int8_rtn(double8);
+int8 __ovld __cnfn convert_int8_rtp(double8);
+int8 __ovld __cnfn convert_int8_rtz(double8);
+int8 __ovld __cnfn convert_int8_sat(double8);
+int8 __ovld __cnfn convert_int8_sat_rte(double8);
+int8 __ovld __cnfn convert_int8_sat_rtn(double8);
+int8 __ovld __cnfn convert_int8_sat_rtp(double8);
+int8 __ovld __cnfn convert_int8_sat_rtz(double8);
+int16 __ovld __cnfn convert_int16(double16);
+int16 __ovld __cnfn convert_int16_rte(double16);
+int16 __ovld __cnfn convert_int16_rtn(double16);
+int16 __ovld __cnfn convert_int16_rtp(double16);
+int16 __ovld __cnfn convert_int16_rtz(double16);
+int16 __ovld __cnfn convert_int16_sat(double16);
+int16 __ovld __cnfn convert_int16_sat_rte(double16);
+int16 __ovld __cnfn convert_int16_sat_rtn(double16);
+int16 __ovld __cnfn convert_int16_sat_rtp(double16);
+int16 __ovld __cnfn convert_int16_sat_rtz(double16);
+
+uint __ovld __cnfn convert_uint(double);
+uint __ovld __cnfn convert_uint_rte(double);
+uint __ovld __cnfn convert_uint_rtn(double);
+uint __ovld __cnfn convert_uint_rtp(double);
+uint __ovld __cnfn convert_uint_rtz(double);
+uint __ovld __cnfn convert_uint_sat(double);
+uint __ovld __cnfn convert_uint_sat_rte(double);
+uint __ovld __cnfn convert_uint_sat_rtn(double);
+uint __ovld __cnfn convert_uint_sat_rtp(double);
+uint __ovld __cnfn convert_uint_sat_rtz(double);
+uint2 __ovld __cnfn convert_uint2(double2);
+uint2 __ovld __cnfn convert_uint2_rte(double2);
+uint2 __ovld __cnfn convert_uint2_rtn(double2);
+uint2 __ovld __cnfn convert_uint2_rtp(double2);
+uint2 __ovld __cnfn convert_uint2_rtz(double2);
+uint2 __ovld __cnfn convert_uint2_sat(double2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(double2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(double2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(double2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(double2);
+uint3 __ovld __cnfn convert_uint3(double3);
+uint3 __ovld __cnfn convert_uint3_rte(double3);
+uint3 __ovld __cnfn convert_uint3_rtn(double3);
+uint3 __ovld __cnfn convert_uint3_rtp(double3);
+uint3 __ovld __cnfn convert_uint3_rtz(double3);
+uint3 __ovld __cnfn convert_uint3_sat(double3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(double3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(double3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(double3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(double3);
+uint4 __ovld __cnfn convert_uint4(double4);
+uint4 __ovld __cnfn convert_uint4_rte(double4);
+uint4 __ovld __cnfn convert_uint4_rtn(double4);
+uint4 __ovld __cnfn convert_uint4_rtp(double4);
+uint4 __ovld __cnfn convert_uint4_rtz(double4);
+uint4 __ovld __cnfn convert_uint4_sat(double4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(double4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(double4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(double4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(double4);
+uint8 __ovld __cnfn convert_uint8(double8);
+uint8 __ovld __cnfn convert_uint8_rte(double8);
+uint8 __ovld __cnfn convert_uint8_rtn(double8);
+uint8 __ovld __cnfn convert_uint8_rtp(double8);
+uint8 __ovld __cnfn convert_uint8_rtz(double8);
+uint8 __ovld __cnfn convert_uint8_sat(double8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(double8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(double8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(double8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(double8);
+uint16 __ovld __cnfn convert_uint16(double16);
+uint16 __ovld __cnfn convert_uint16_rte(double16);
+uint16 __ovld __cnfn convert_uint16_rtn(double16);
+uint16 __ovld __cnfn convert_uint16_rtp(double16);
+uint16 __ovld __cnfn convert_uint16_rtz(double16);
+uint16 __ovld __cnfn convert_uint16_sat(double16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(double16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(double16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(double16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(double16);
+
+long __ovld __cnfn convert_long(double);
+long __ovld __cnfn convert_long_rte(double);
+long __ovld __cnfn convert_long_rtn(double);
+long __ovld __cnfn convert_long_rtp(double);
+long __ovld __cnfn convert_long_rtz(double);
+long __ovld __cnfn convert_long_sat(double);
+long __ovld __cnfn convert_long_sat_rte(double);
+long __ovld __cnfn convert_long_sat_rtn(double);
+long __ovld __cnfn convert_long_sat_rtp(double);
+long __ovld __cnfn convert_long_sat_rtz(double);
+long2 __ovld __cnfn convert_long2(double2);
+long2 __ovld __cnfn convert_long2_rte(double2);
+long2 __ovld __cnfn convert_long2_rtn(double2);
+long2 __ovld __cnfn convert_long2_rtp(double2);
+long2 __ovld __cnfn convert_long2_rtz(double2);
+long2 __ovld __cnfn convert_long2_sat(double2);
+long2 __ovld __cnfn convert_long2_sat_rte(double2);
+long2 __ovld __cnfn convert_long2_sat_rtn(double2);
+long2 __ovld __cnfn convert_long2_sat_rtp(double2);
+long2 __ovld __cnfn convert_long2_sat_rtz(double2);
+long3 __ovld __cnfn convert_long3(double3);
+long3 __ovld __cnfn convert_long3_rte(double3);
+long3 __ovld __cnfn convert_long3_rtn(double3);
+long3 __ovld __cnfn convert_long3_rtp(double3);
+long3 __ovld __cnfn convert_long3_rtz(double3);
+long3 __ovld __cnfn convert_long3_sat(double3);
+long3 __ovld __cnfn convert_long3_sat_rte(double3);
+long3 __ovld __cnfn convert_long3_sat_rtn(double3);
+long3 __ovld __cnfn convert_long3_sat_rtp(double3);
+long3 __ovld __cnfn convert_long3_sat_rtz(double3);
+long4 __ovld __cnfn convert_long4(double4);
+long4 __ovld __cnfn convert_long4_rte(double4);
+long4 __ovld __cnfn convert_long4_rtn(double4);
+long4 __ovld __cnfn convert_long4_rtp(double4);
+long4 __ovld __cnfn convert_long4_rtz(double4);
+long4 __ovld __cnfn convert_long4_sat(double4);
+long4 __ovld __cnfn convert_long4_sat_rte(double4);
+long4 __ovld __cnfn convert_long4_sat_rtn(double4);
+long4 __ovld __cnfn convert_long4_sat_rtp(double4);
+long4 __ovld __cnfn convert_long4_sat_rtz(double4);
+long8 __ovld __cnfn convert_long8(double8);
+long8 __ovld __cnfn convert_long8_rte(double8);
+long8 __ovld __cnfn convert_long8_rtn(double8);
+long8 __ovld __cnfn convert_long8_rtp(double8);
+long8 __ovld __cnfn convert_long8_rtz(double8);
+long8 __ovld __cnfn convert_long8_sat(double8);
+long8 __ovld __cnfn convert_long8_sat_rte(double8);
+long8 __ovld __cnfn convert_long8_sat_rtn(double8);
+long8 __ovld __cnfn convert_long8_sat_rtp(double8);
+long8 __ovld __cnfn convert_long8_sat_rtz(double8);
+long16 __ovld __cnfn convert_long16(double16);
+long16 __ovld __cnfn convert_long16_rte(double16);
+long16 __ovld __cnfn convert_long16_rtn(double16);
+long16 __ovld __cnfn convert_long16_rtp(double16);
+long16 __ovld __cnfn convert_long16_rtz(double16);
+long16 __ovld __cnfn convert_long16_sat(double16);
+long16 __ovld __cnfn convert_long16_sat_rte(double16);
+long16 __ovld __cnfn convert_long16_sat_rtn(double16);
+long16 __ovld __cnfn convert_long16_sat_rtp(double16);
+long16 __ovld __cnfn convert_long16_sat_rtz(double16);
+
+ulong __ovld __cnfn convert_ulong(double);
+ulong __ovld __cnfn convert_ulong_rte(double);
+ulong __ovld __cnfn convert_ulong_rtn(double);
+ulong __ovld __cnfn convert_ulong_rtp(double);
+ulong __ovld __cnfn convert_ulong_rtz(double);
+ulong __ovld __cnfn convert_ulong_sat(double);
+ulong __ovld __cnfn convert_ulong_sat_rte(double);
+ulong __ovld __cnfn convert_ulong_sat_rtn(double);
+ulong __ovld __cnfn convert_ulong_sat_rtp(double);
+ulong __ovld __cnfn convert_ulong_sat_rtz(double);
+ulong2 __ovld __cnfn convert_ulong2(double2);
+ulong2 __ovld __cnfn convert_ulong2_rte(double2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(double2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(double2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(double2);
+ulong2 __ovld __cnfn convert_ulong2_sat(double2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(double2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(double2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(double2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(double2);
+ulong3 __ovld __cnfn convert_ulong3(double3);
+ulong3 __ovld __cnfn convert_ulong3_rte(double3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(double3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(double3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(double3);
+ulong3 __ovld __cnfn convert_ulong3_sat(double3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(double3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(double3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(double3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(double3);
+ulong4 __ovld __cnfn convert_ulong4(double4);
+ulong4 __ovld __cnfn convert_ulong4_rte(double4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(double4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(double4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(double4);
+ulong4 __ovld __cnfn convert_ulong4_sat(double4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(double4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(double4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(double4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(double4);
+ulong8 __ovld __cnfn convert_ulong8(double8);
+ulong8 __ovld __cnfn convert_ulong8_rte(double8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(double8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(double8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(double8);
+ulong8 __ovld __cnfn convert_ulong8_sat(double8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(double8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(double8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(double8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(double8);
+ulong16 __ovld __cnfn convert_ulong16(double16);
+ulong16 __ovld __cnfn convert_ulong16_rte(double16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(double16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(double16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(double16);
+ulong16 __ovld __cnfn convert_ulong16_sat(double16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(double16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(double16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(double16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(double16);
+
+float __ovld __cnfn convert_float(double);
+float __ovld __cnfn convert_float_rte(double);
+float __ovld __cnfn convert_float_rtn(double);
+float __ovld __cnfn convert_float_rtp(double);
+float __ovld __cnfn convert_float_rtz(double);
+float2 __ovld __cnfn convert_float2(double2);
+float2 __ovld __cnfn convert_float2_rte(double2);
+float2 __ovld __cnfn convert_float2_rtn(double2);
+float2 __ovld __cnfn convert_float2_rtp(double2);
+float2 __ovld __cnfn convert_float2_rtz(double2);
+float3 __ovld __cnfn convert_float3(double3);
+float3 __ovld __cnfn convert_float3_rte(double3);
+float3 __ovld __cnfn convert_float3_rtn(double3);
+float3 __ovld __cnfn convert_float3_rtp(double3);
+float3 __ovld __cnfn convert_float3_rtz(double3);
+float4 __ovld __cnfn convert_float4(double4);
+float4 __ovld __cnfn convert_float4_rte(double4);
+float4 __ovld __cnfn convert_float4_rtn(double4);
+float4 __ovld __cnfn convert_float4_rtp(double4);
+float4 __ovld __cnfn convert_float4_rtz(double4);
+float8 __ovld __cnfn convert_float8(double8);
+float8 __ovld __cnfn convert_float8_rte(double8);
+float8 __ovld __cnfn convert_float8_rtn(double8);
+float8 __ovld __cnfn convert_float8_rtp(double8);
+float8 __ovld __cnfn convert_float8_rtz(double8);
+float16 __ovld __cnfn convert_float16(double16);
+float16 __ovld __cnfn convert_float16_rte(double16);
+float16 __ovld __cnfn convert_float16_rtn(double16);
+float16 __ovld __cnfn convert_float16_rtp(double16);
+float16 __ovld __cnfn convert_float16_rtz(double16);
+
+double __ovld __cnfn convert_double(char);
+double __ovld __cnfn convert_double(double);
+double __ovld __cnfn convert_double(float);
+double __ovld __cnfn convert_double(int);
+double __ovld __cnfn convert_double(long);
+double __ovld __cnfn convert_double(short);
+double __ovld __cnfn convert_double(uchar);
+double __ovld __cnfn convert_double(uint);
+double __ovld __cnfn convert_double(ulong);
+double __ovld __cnfn convert_double(ushort);
+double __ovld __cnfn convert_double_rte(char);
+double __ovld __cnfn convert_double_rte(double);
+double __ovld __cnfn convert_double_rte(float);
+double __ovld __cnfn convert_double_rte(int);
+double __ovld __cnfn convert_double_rte(long);
+double __ovld __cnfn convert_double_rte(short);
+double __ovld __cnfn convert_double_rte(uchar);
+double __ovld __cnfn convert_double_rte(uint);
+double __ovld __cnfn convert_double_rte(ulong);
+double __ovld __cnfn convert_double_rte(ushort);
+double __ovld __cnfn convert_double_rtn(char);
+double __ovld __cnfn convert_double_rtn(double);
+double __ovld __cnfn convert_double_rtn(float);
+double __ovld __cnfn convert_double_rtn(int);
+double __ovld __cnfn convert_double_rtn(long);
+double __ovld __cnfn convert_double_rtn(short);
+double __ovld __cnfn convert_double_rtn(uchar);
+double __ovld __cnfn convert_double_rtn(uint);
+double __ovld __cnfn convert_double_rtn(ulong);
+double __ovld __cnfn convert_double_rtn(ushort);
+double __ovld __cnfn convert_double_rtp(char);
+double __ovld __cnfn convert_double_rtp(double);
+double __ovld __cnfn convert_double_rtp(float);
+double __ovld __cnfn convert_double_rtp(int);
+double __ovld __cnfn convert_double_rtp(long);
+double __ovld __cnfn convert_double_rtp(short);
+double __ovld __cnfn convert_double_rtp(uchar);
+double __ovld __cnfn convert_double_rtp(uint);
+double __ovld __cnfn convert_double_rtp(ulong);
+double __ovld __cnfn convert_double_rtp(ushort);
+double __ovld __cnfn convert_double_rtz(char);
+double __ovld __cnfn convert_double_rtz(double);
+double __ovld __cnfn convert_double_rtz(float);
+double __ovld __cnfn convert_double_rtz(int);
+double __ovld __cnfn convert_double_rtz(long);
+double __ovld __cnfn convert_double_rtz(short);
+double __ovld __cnfn convert_double_rtz(uchar);
+double __ovld __cnfn convert_double_rtz(uint);
+double __ovld __cnfn convert_double_rtz(ulong);
+double __ovld __cnfn convert_double_rtz(ushort);
+double2 __ovld __cnfn convert_double2(char2);
+double2 __ovld __cnfn convert_double2(double2);
+double2 __ovld __cnfn convert_double2(float2);
+double2 __ovld __cnfn convert_double2(int2);
+double2 __ovld __cnfn convert_double2(long2);
+double2 __ovld __cnfn convert_double2(short2);
+double2 __ovld __cnfn convert_double2(uchar2);
+double2 __ovld __cnfn convert_double2(uint2);
+double2 __ovld __cnfn convert_double2(ulong2);
+double2 __ovld __cnfn convert_double2(ushort2);
+double2 __ovld __cnfn convert_double2_rte(char2);
+double2 __ovld __cnfn convert_double2_rte(double2);
+double2 __ovld __cnfn convert_double2_rte(float2);
+double2 __ovld __cnfn convert_double2_rte(int2);
+double2 __ovld __cnfn convert_double2_rte(long2);
+double2 __ovld __cnfn convert_double2_rte(short2);
+double2 __ovld __cnfn convert_double2_rte(uchar2);
+double2 __ovld __cnfn convert_double2_rte(uint2);
+double2 __ovld __cnfn convert_double2_rte(ulong2);
+double2 __ovld __cnfn convert_double2_rte(ushort2);
+double2 __ovld __cnfn convert_double2_rtn(char2);
+double2 __ovld __cnfn convert_double2_rtn(double2);
+double2 __ovld __cnfn convert_double2_rtn(float2);
+double2 __ovld __cnfn convert_double2_rtn(int2);
+double2 __ovld __cnfn convert_double2_rtn(long2);
+double2 __ovld __cnfn convert_double2_rtn(short2);
+double2 __ovld __cnfn convert_double2_rtn(uchar2);
+double2 __ovld __cnfn convert_double2_rtn(uint2);
+double2 __ovld __cnfn convert_double2_rtn(ulong2);
+double2 __ovld __cnfn convert_double2_rtn(ushort2);
+double2 __ovld __cnfn convert_double2_rtp(char2);
+double2 __ovld __cnfn convert_double2_rtp(double2);
+double2 __ovld __cnfn convert_double2_rtp(float2);
+double2 __ovld __cnfn convert_double2_rtp(int2);
+double2 __ovld __cnfn convert_double2_rtp(long2);
+double2 __ovld __cnfn convert_double2_rtp(short2);
+double2 __ovld __cnfn convert_double2_rtp(uchar2);
+double2 __ovld __cnfn convert_double2_rtp(uint2);
+double2 __ovld __cnfn convert_double2_rtp(ulong2);
+double2 __ovld __cnfn convert_double2_rtp(ushort2);
+double2 __ovld __cnfn convert_double2_rtz(char2);
+double2 __ovld __cnfn convert_double2_rtz(double2);
+double2 __ovld __cnfn convert_double2_rtz(float2);
+double2 __ovld __cnfn convert_double2_rtz(int2);
+double2 __ovld __cnfn convert_double2_rtz(long2);
+double2 __ovld __cnfn convert_double2_rtz(short2);
+double2 __ovld __cnfn convert_double2_rtz(uchar2);
+double2 __ovld __cnfn convert_double2_rtz(uint2);
+double2 __ovld __cnfn convert_double2_rtz(ulong2);
+double2 __ovld __cnfn convert_double2_rtz(ushort2);
+double3 __ovld __cnfn convert_double3(char3);
+double3 __ovld __cnfn convert_double3(double3);
+double3 __ovld __cnfn convert_double3(float3);
+double3 __ovld __cnfn convert_double3(int3);
+double3 __ovld __cnfn convert_double3(long3);
+double3 __ovld __cnfn convert_double3(short3);
+double3 __ovld __cnfn convert_double3(uchar3);
+double3 __ovld __cnfn convert_double3(uint3);
+double3 __ovld __cnfn convert_double3(ulong3);
+double3 __ovld __cnfn convert_double3(ushort3);
+double3 __ovld __cnfn convert_double3_rte(char3);
+double3 __ovld __cnfn convert_double3_rte(double3);
+double3 __ovld __cnfn convert_double3_rte(float3);
+double3 __ovld __cnfn convert_double3_rte(int3);
+double3 __ovld __cnfn convert_double3_rte(long3);
+double3 __ovld __cnfn convert_double3_rte(short3);
+double3 __ovld __cnfn convert_double3_rte(uchar3);
+double3 __ovld __cnfn convert_double3_rte(uint3);
+double3 __ovld __cnfn convert_double3_rte(ulong3);
+double3 __ovld __cnfn convert_double3_rte(ushort3);
+double3 __ovld __cnfn convert_double3_rtn(char3);
+double3 __ovld __cnfn convert_double3_rtn(double3);
+double3 __ovld __cnfn convert_double3_rtn(float3);
+double3 __ovld __cnfn convert_double3_rtn(int3);
+double3 __ovld __cnfn convert_double3_rtn(long3);
+double3 __ovld __cnfn convert_double3_rtn(short3);
+double3 __ovld __cnfn convert_double3_rtn(uchar3);
+double3 __ovld __cnfn convert_double3_rtn(uint3);
+double3 __ovld __cnfn convert_double3_rtn(ulong3);
+double3 __ovld __cnfn convert_double3_rtn(ushort3);
+double3 __ovld __cnfn convert_double3_rtp(char3);
+double3 __ovld __cnfn convert_double3_rtp(double3);
+double3 __ovld __cnfn convert_double3_rtp(float3);
+double3 __ovld __cnfn convert_double3_rtp(int3);
+double3 __ovld __cnfn convert_double3_rtp(long3);
+double3 __ovld __cnfn convert_double3_rtp(short3);
+double3 __ovld __cnfn convert_double3_rtp(uchar3);
+double3 __ovld __cnfn convert_double3_rtp(uint3);
+double3 __ovld __cnfn convert_double3_rtp(ulong3);
+double3 __ovld __cnfn convert_double3_rtp(ushort3);
+double3 __ovld __cnfn convert_double3_rtz(char3);
+double3 __ovld __cnfn convert_double3_rtz(double3);
+double3 __ovld __cnfn convert_double3_rtz(float3);
+double3 __ovld __cnfn convert_double3_rtz(int3);
+double3 __ovld __cnfn convert_double3_rtz(long3);
+double3 __ovld __cnfn convert_double3_rtz(short3);
+double3 __ovld __cnfn convert_double3_rtz(uchar3);
+double3 __ovld __cnfn convert_double3_rtz(uint3);
+double3 __ovld __cnfn convert_double3_rtz(ulong3);
+double3 __ovld __cnfn convert_double3_rtz(ushort3);
+double4 __ovld __cnfn convert_double4(char4);
+double4 __ovld __cnfn convert_double4(double4);
+double4 __ovld __cnfn convert_double4(float4);
+double4 __ovld __cnfn convert_double4(int4);
+double4 __ovld __cnfn convert_double4(long4);
+double4 __ovld __cnfn convert_double4(short4);
+double4 __ovld __cnfn convert_double4(uchar4);
+double4 __ovld __cnfn convert_double4(uint4);
+double4 __ovld __cnfn convert_double4(ulong4);
+double4 __ovld __cnfn convert_double4(ushort4);
+double4 __ovld __cnfn convert_double4_rte(char4);
+double4 __ovld __cnfn convert_double4_rte(double4);
+double4 __ovld __cnfn convert_double4_rte(float4);
+double4 __ovld __cnfn convert_double4_rte(int4);
+double4 __ovld __cnfn convert_double4_rte(long4);
+double4 __ovld __cnfn convert_double4_rte(short4);
+double4 __ovld __cnfn convert_double4_rte(uchar4);
+double4 __ovld __cnfn convert_double4_rte(uint4);
+double4 __ovld __cnfn convert_double4_rte(ulong4);
+double4 __ovld __cnfn convert_double4_rte(ushort4);
+double4 __ovld __cnfn convert_double4_rtn(char4);
+double4 __ovld __cnfn convert_double4_rtn(double4);
+double4 __ovld __cnfn convert_double4_rtn(float4);
+double4 __ovld __cnfn convert_double4_rtn(int4);
+double4 __ovld __cnfn convert_double4_rtn(long4);
+double4 __ovld __cnfn convert_double4_rtn(short4);
+double4 __ovld __cnfn convert_double4_rtn(uchar4);
+double4 __ovld __cnfn convert_double4_rtn(uint4);
+double4 __ovld __cnfn convert_double4_rtn(ulong4);
+double4 __ovld __cnfn convert_double4_rtn(ushort4);
+double4 __ovld __cnfn convert_double4_rtp(char4);
+double4 __ovld __cnfn convert_double4_rtp(double4);
+double4 __ovld __cnfn convert_double4_rtp(float4);
+double4 __ovld __cnfn convert_double4_rtp(int4);
+double4 __ovld __cnfn convert_double4_rtp(long4);
+double4 __ovld __cnfn convert_double4_rtp(short4);
+double4 __ovld __cnfn convert_double4_rtp(uchar4);
+double4 __ovld __cnfn convert_double4_rtp(uint4);
+double4 __ovld __cnfn convert_double4_rtp(ulong4);
+double4 __ovld __cnfn convert_double4_rtp(ushort4);
+double4 __ovld __cnfn convert_double4_rtz(char4);
+double4 __ovld __cnfn convert_double4_rtz(double4);
+double4 __ovld __cnfn convert_double4_rtz(float4);
+double4 __ovld __cnfn convert_double4_rtz(int4);
+double4 __ovld __cnfn convert_double4_rtz(long4);
+double4 __ovld __cnfn convert_double4_rtz(short4);
+double4 __ovld __cnfn convert_double4_rtz(uchar4);
+double4 __ovld __cnfn convert_double4_rtz(uint4);
+double4 __ovld __cnfn convert_double4_rtz(ulong4);
+double4 __ovld __cnfn convert_double4_rtz(ushort4);
+double8 __ovld __cnfn convert_double8(char8);
+double8 __ovld __cnfn convert_double8(double8);
+double8 __ovld __cnfn convert_double8(float8);
+double8 __ovld __cnfn convert_double8(int8);
+double8 __ovld __cnfn convert_double8(long8);
+double8 __ovld __cnfn convert_double8(short8);
+double8 __ovld __cnfn convert_double8(uchar8);
+double8 __ovld __cnfn convert_double8(uint8);
+double8 __ovld __cnfn convert_double8(ulong8);
+double8 __ovld __cnfn convert_double8(ushort8);
+double8 __ovld __cnfn convert_double8_rte(char8);
+double8 __ovld __cnfn convert_double8_rte(double8);
+double8 __ovld __cnfn convert_double8_rte(float8);
+double8 __ovld __cnfn convert_double8_rte(int8);
+double8 __ovld __cnfn convert_double8_rte(long8);
+double8 __ovld __cnfn convert_double8_rte(short8);
+double8 __ovld __cnfn convert_double8_rte(uchar8);
+double8 __ovld __cnfn convert_double8_rte(uint8);
+double8 __ovld __cnfn convert_double8_rte(ulong8);
+double8 __ovld __cnfn convert_double8_rte(ushort8);
+double8 __ovld __cnfn convert_double8_rtn(char8);
+double8 __ovld __cnfn convert_double8_rtn(double8);
+double8 __ovld __cnfn convert_double8_rtn(float8);
+double8 __ovld __cnfn convert_double8_rtn(int8);
+double8 __ovld __cnfn convert_double8_rtn(long8);
+double8 __ovld __cnfn convert_double8_rtn(short8);
+double8 __ovld __cnfn convert_double8_rtn(uchar8);
+double8 __ovld __cnfn convert_double8_rtn(uint8);
+double8 __ovld __cnfn convert_double8_rtn(ulong8);
+double8 __ovld __cnfn convert_double8_rtn(ushort8);
+double8 __ovld __cnfn convert_double8_rtp(char8);
+double8 __ovld __cnfn convert_double8_rtp(double8);
+double8 __ovld __cnfn convert_double8_rtp(float8);
+double8 __ovld __cnfn convert_double8_rtp(int8);
+double8 __ovld __cnfn convert_double8_rtp(long8);
+double8 __ovld __cnfn convert_double8_rtp(short8);
+double8 __ovld __cnfn convert_double8_rtp(uchar8);
+double8 __ovld __cnfn convert_double8_rtp(uint8);
+double8 __ovld __cnfn convert_double8_rtp(ulong8);
+double8 __ovld __cnfn convert_double8_rtp(ushort8);
+double8 __ovld __cnfn convert_double8_rtz(char8);
+double8 __ovld __cnfn convert_double8_rtz(double8);
+double8 __ovld __cnfn convert_double8_rtz(float8);
+double8 __ovld __cnfn convert_double8_rtz(int8);
+double8 __ovld __cnfn convert_double8_rtz(long8);
+double8 __ovld __cnfn convert_double8_rtz(short8);
+double8 __ovld __cnfn convert_double8_rtz(uchar8);
+double8 __ovld __cnfn convert_double8_rtz(uint8);
+double8 __ovld __cnfn convert_double8_rtz(ulong8);
+double8 __ovld __cnfn convert_double8_rtz(ushort8);
+double16 __ovld __cnfn convert_double16(char16);
+double16 __ovld __cnfn convert_double16(double16);
+double16 __ovld __cnfn convert_double16(float16);
+double16 __ovld __cnfn convert_double16(int16);
+double16 __ovld __cnfn convert_double16(long16);
+double16 __ovld __cnfn convert_double16(short16);
+double16 __ovld __cnfn convert_double16(uchar16);
+double16 __ovld __cnfn convert_double16(uint16);
+double16 __ovld __cnfn convert_double16(ulong16);
+double16 __ovld __cnfn convert_double16(ushort16);
+double16 __ovld __cnfn convert_double16_rte(char16);
+double16 __ovld __cnfn convert_double16_rte(double16);
+double16 __ovld __cnfn convert_double16_rte(float16);
+double16 __ovld __cnfn convert_double16_rte(int16);
+double16 __ovld __cnfn convert_double16_rte(long16);
+double16 __ovld __cnfn convert_double16_rte(short16);
+double16 __ovld __cnfn convert_double16_rte(uchar16);
+double16 __ovld __cnfn convert_double16_rte(uint16);
+double16 __ovld __cnfn convert_double16_rte(ulong16);
+double16 __ovld __cnfn convert_double16_rte(ushort16);
+double16 __ovld __cnfn convert_double16_rtn(char16);
+double16 __ovld __cnfn convert_double16_rtn(double16);
+double16 __ovld __cnfn convert_double16_rtn(float16);
+double16 __ovld __cnfn convert_double16_rtn(int16);
+double16 __ovld __cnfn convert_double16_rtn(long16);
+double16 __ovld __cnfn convert_double16_rtn(short16);
+double16 __ovld __cnfn convert_double16_rtn(uchar16);
+double16 __ovld __cnfn convert_double16_rtn(uint16);
+double16 __ovld __cnfn convert_double16_rtn(ulong16);
+double16 __ovld __cnfn convert_double16_rtn(ushort16);
+double16 __ovld __cnfn convert_double16_rtp(char16);
+double16 __ovld __cnfn convert_double16_rtp(double16);
+double16 __ovld __cnfn convert_double16_rtp(float16);
+double16 __ovld __cnfn convert_double16_rtp(int16);
+double16 __ovld __cnfn convert_double16_rtp(long16);
+double16 __ovld __cnfn convert_double16_rtp(short16);
+double16 __ovld __cnfn convert_double16_rtp(uchar16);
+double16 __ovld __cnfn convert_double16_rtp(uint16);
+double16 __ovld __cnfn convert_double16_rtp(ulong16);
+double16 __ovld __cnfn convert_double16_rtp(ushort16);
+double16 __ovld __cnfn convert_double16_rtz(char16);
+double16 __ovld __cnfn convert_double16_rtz(double16);
+double16 __ovld __cnfn convert_double16_rtz(float16);
+double16 __ovld __cnfn convert_double16_rtz(int16);
+double16 __ovld __cnfn convert_double16_rtz(long16);
+double16 __ovld __cnfn convert_double16_rtz(short16);
+double16 __ovld __cnfn convert_double16_rtz(uchar16);
+double16 __ovld __cnfn convert_double16_rtz(uint16);
+double16 __ovld __cnfn convert_double16_rtz(ulong16);
+double16 __ovld __cnfn convert_double16_rtz(ushort16);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+// Convert half types to non-double types.
+uchar __ovld __cnfn convert_uchar(half);
+uchar __ovld __cnfn convert_uchar_rte(half);
+uchar __ovld __cnfn convert_uchar_rtp(half);
+uchar __ovld __cnfn convert_uchar_rtn(half);
+uchar __ovld __cnfn convert_uchar_rtz(half);
+uchar __ovld __cnfn convert_uchar_sat(half);
+uchar __ovld __cnfn convert_uchar_sat_rte(half);
+uchar __ovld __cnfn convert_uchar_sat_rtp(half);
+uchar __ovld __cnfn convert_uchar_sat_rtn(half);
+uchar __ovld __cnfn convert_uchar_sat_rtz(half);
+uchar2 __ovld __cnfn convert_uchar2(half2);
+uchar2 __ovld __cnfn convert_uchar2_rte(half2);
+uchar2 __ovld __cnfn convert_uchar2_rtp(half2);
+uchar2 __ovld __cnfn convert_uchar2_rtn(half2);
+uchar2 __ovld __cnfn convert_uchar2_rtz(half2);
+uchar2 __ovld __cnfn convert_uchar2_sat(half2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rte(half2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtp(half2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtn(half2);
+uchar2 __ovld __cnfn convert_uchar2_sat_rtz(half2);
+uchar3 __ovld __cnfn convert_uchar3(half3);
+uchar3 __ovld __cnfn convert_uchar3_rte(half3);
+uchar3 __ovld __cnfn convert_uchar3_rtp(half3);
+uchar3 __ovld __cnfn convert_uchar3_rtn(half3);
+uchar3 __ovld __cnfn convert_uchar3_rtz(half3);
+uchar3 __ovld __cnfn convert_uchar3_sat(half3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rte(half3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtp(half3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtn(half3);
+uchar3 __ovld __cnfn convert_uchar3_sat_rtz(half3);
+uchar4 __ovld __cnfn convert_uchar4(half4);
+uchar4 __ovld __cnfn convert_uchar4_rte(half4);
+uchar4 __ovld __cnfn convert_uchar4_rtp(half4);
+uchar4 __ovld __cnfn convert_uchar4_rtn(half4);
+uchar4 __ovld __cnfn convert_uchar4_rtz(half4);
+uchar4 __ovld __cnfn convert_uchar4_sat(half4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rte(half4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtp(half4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtn(half4);
+uchar4 __ovld __cnfn convert_uchar4_sat_rtz(half4);
+uchar8 __ovld __cnfn convert_uchar8(half8);
+uchar8 __ovld __cnfn convert_uchar8_rte(half8);
+uchar8 __ovld __cnfn convert_uchar8_rtp(half8);
+uchar8 __ovld __cnfn convert_uchar8_rtn(half8);
+uchar8 __ovld __cnfn convert_uchar8_rtz(half8);
+uchar8 __ovld __cnfn convert_uchar8_sat(half8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rte(half8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtp(half8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtn(half8);
+uchar8 __ovld __cnfn convert_uchar8_sat_rtz(half8);
+uchar16 __ovld __cnfn convert_uchar16(half16);
+uchar16 __ovld __cnfn convert_uchar16_rte(half16);
+uchar16 __ovld __cnfn convert_uchar16_rtp(half16);
+uchar16 __ovld __cnfn convert_uchar16_rtn(half16);
+uchar16 __ovld __cnfn convert_uchar16_rtz(half16);
+uchar16 __ovld __cnfn convert_uchar16_sat(half16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rte(half16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtp(half16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtn(half16);
+uchar16 __ovld __cnfn convert_uchar16_sat_rtz(half16);
+ushort __ovld __cnfn convert_ushort(half);
+ushort __ovld __cnfn convert_ushort_rte(half);
+ushort __ovld __cnfn convert_ushort_rtp(half);
+ushort __ovld __cnfn convert_ushort_rtn(half);
+ushort __ovld __cnfn convert_ushort_rtz(half);
+ushort __ovld __cnfn convert_ushort_sat(half);
+ushort __ovld __cnfn convert_ushort_sat_rte(half);
+ushort __ovld __cnfn convert_ushort_sat_rtp(half);
+ushort __ovld __cnfn convert_ushort_sat_rtn(half);
+ushort __ovld __cnfn convert_ushort_sat_rtz(half);
+ushort2 __ovld __cnfn convert_ushort2(half2);
+ushort2 __ovld __cnfn convert_ushort2_rte(half2);
+ushort2 __ovld __cnfn convert_ushort2_rtp(half2);
+ushort2 __ovld __cnfn convert_ushort2_rtn(half2);
+ushort2 __ovld __cnfn convert_ushort2_rtz(half2);
+ushort2 __ovld __cnfn convert_ushort2_sat(half2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rte(half2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtp(half2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtn(half2);
+ushort2 __ovld __cnfn convert_ushort2_sat_rtz(half2);
+ushort3 __ovld __cnfn convert_ushort3(half3);
+ushort3 __ovld __cnfn convert_ushort3_rte(half3);
+ushort3 __ovld __cnfn convert_ushort3_rtp(half3);
+ushort3 __ovld __cnfn convert_ushort3_rtn(half3);
+ushort3 __ovld __cnfn convert_ushort3_rtz(half3);
+ushort3 __ovld __cnfn convert_ushort3_sat(half3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rte(half3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtp(half3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtn(half3);
+ushort3 __ovld __cnfn convert_ushort3_sat_rtz(half3);
+ushort4 __ovld __cnfn convert_ushort4(half4);
+ushort4 __ovld __cnfn convert_ushort4_rte(half4);
+ushort4 __ovld __cnfn convert_ushort4_rtp(half4);
+ushort4 __ovld __cnfn convert_ushort4_rtn(half4);
+ushort4 __ovld __cnfn convert_ushort4_rtz(half4);
+ushort4 __ovld __cnfn convert_ushort4_sat(half4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rte(half4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtp(half4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtn(half4);
+ushort4 __ovld __cnfn convert_ushort4_sat_rtz(half4);
+ushort8 __ovld __cnfn convert_ushort8(half8);
+ushort8 __ovld __cnfn convert_ushort8_rte(half8);
+ushort8 __ovld __cnfn convert_ushort8_rtp(half8);
+ushort8 __ovld __cnfn convert_ushort8_rtn(half8);
+ushort8 __ovld __cnfn convert_ushort8_rtz(half8);
+ushort8 __ovld __cnfn convert_ushort8_sat(half8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rte(half8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtp(half8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtn(half8);
+ushort8 __ovld __cnfn convert_ushort8_sat_rtz(half8);
+ushort16 __ovld __cnfn convert_ushort16(half16);
+ushort16 __ovld __cnfn convert_ushort16_rte(half16);
+ushort16 __ovld __cnfn convert_ushort16_rtp(half16);
+ushort16 __ovld __cnfn convert_ushort16_rtn(half16);
+ushort16 __ovld __cnfn convert_ushort16_rtz(half16);
+ushort16 __ovld __cnfn convert_ushort16_sat(half16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rte(half16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtp(half16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtn(half16);
+ushort16 __ovld __cnfn convert_ushort16_sat_rtz(half16);
+uint __ovld __cnfn convert_uint(half);
+uint __ovld __cnfn convert_uint_rte(half);
+uint __ovld __cnfn convert_uint_rtp(half);
+uint __ovld __cnfn convert_uint_rtn(half);
+uint __ovld __cnfn convert_uint_rtz(half);
+uint __ovld __cnfn convert_uint_sat(half);
+uint __ovld __cnfn convert_uint_sat_rte(half);
+uint __ovld __cnfn convert_uint_sat_rtp(half);
+uint __ovld __cnfn convert_uint_sat_rtn(half);
+uint __ovld __cnfn convert_uint_sat_rtz(half);
+uint2 __ovld __cnfn convert_uint2(half2);
+uint2 __ovld __cnfn convert_uint2_rte(half2);
+uint2 __ovld __cnfn convert_uint2_rtp(half2);
+uint2 __ovld __cnfn convert_uint2_rtn(half2);
+uint2 __ovld __cnfn convert_uint2_rtz(half2);
+uint2 __ovld __cnfn convert_uint2_sat(half2);
+uint2 __ovld __cnfn convert_uint2_sat_rte(half2);
+uint2 __ovld __cnfn convert_uint2_sat_rtp(half2);
+uint2 __ovld __cnfn convert_uint2_sat_rtn(half2);
+uint2 __ovld __cnfn convert_uint2_sat_rtz(half2);
+uint3 __ovld __cnfn convert_uint3(half3);
+uint3 __ovld __cnfn convert_uint3_rte(half3);
+uint3 __ovld __cnfn convert_uint3_rtp(half3);
+uint3 __ovld __cnfn convert_uint3_rtn(half3);
+uint3 __ovld __cnfn convert_uint3_rtz(half3);
+uint3 __ovld __cnfn convert_uint3_sat(half3);
+uint3 __ovld __cnfn convert_uint3_sat_rte(half3);
+uint3 __ovld __cnfn convert_uint3_sat_rtp(half3);
+uint3 __ovld __cnfn convert_uint3_sat_rtn(half3);
+uint3 __ovld __cnfn convert_uint3_sat_rtz(half3);
+uint4 __ovld __cnfn convert_uint4(half4);
+uint4 __ovld __cnfn convert_uint4_rte(half4);
+uint4 __ovld __cnfn convert_uint4_rtp(half4);
+uint4 __ovld __cnfn convert_uint4_rtn(half4);
+uint4 __ovld __cnfn convert_uint4_rtz(half4);
+uint4 __ovld __cnfn convert_uint4_sat(half4);
+uint4 __ovld __cnfn convert_uint4_sat_rte(half4);
+uint4 __ovld __cnfn convert_uint4_sat_rtp(half4);
+uint4 __ovld __cnfn convert_uint4_sat_rtn(half4);
+uint4 __ovld __cnfn convert_uint4_sat_rtz(half4);
+uint8 __ovld __cnfn convert_uint8(half8);
+uint8 __ovld __cnfn convert_uint8_rte(half8);
+uint8 __ovld __cnfn convert_uint8_rtp(half8);
+uint8 __ovld __cnfn convert_uint8_rtn(half8);
+uint8 __ovld __cnfn convert_uint8_rtz(half8);
+uint8 __ovld __cnfn convert_uint8_sat(half8);
+uint8 __ovld __cnfn convert_uint8_sat_rte(half8);
+uint8 __ovld __cnfn convert_uint8_sat_rtp(half8);
+uint8 __ovld __cnfn convert_uint8_sat_rtn(half8);
+uint8 __ovld __cnfn convert_uint8_sat_rtz(half8);
+uint16 __ovld __cnfn convert_uint16(half16);
+uint16 __ovld __cnfn convert_uint16_rte(half16);
+uint16 __ovld __cnfn convert_uint16_rtp(half16);
+uint16 __ovld __cnfn convert_uint16_rtn(half16);
+uint16 __ovld __cnfn convert_uint16_rtz(half16);
+uint16 __ovld __cnfn convert_uint16_sat(half16);
+uint16 __ovld __cnfn convert_uint16_sat_rte(half16);
+uint16 __ovld __cnfn convert_uint16_sat_rtp(half16);
+uint16 __ovld __cnfn convert_uint16_sat_rtn(half16);
+uint16 __ovld __cnfn convert_uint16_sat_rtz(half16);
+ulong __ovld __cnfn convert_ulong(half);
+ulong __ovld __cnfn convert_ulong_rte(half);
+ulong __ovld __cnfn convert_ulong_rtp(half);
+ulong __ovld __cnfn convert_ulong_rtn(half);
+ulong __ovld __cnfn convert_ulong_rtz(half);
+ulong __ovld __cnfn convert_ulong_sat(half);
+ulong __ovld __cnfn convert_ulong_sat_rte(half);
+ulong __ovld __cnfn convert_ulong_sat_rtp(half);
+ulong __ovld __cnfn convert_ulong_sat_rtn(half);
+ulong __ovld __cnfn convert_ulong_sat_rtz(half);
+ulong2 __ovld __cnfn convert_ulong2(half2);
+ulong2 __ovld __cnfn convert_ulong2_rte(half2);
+ulong2 __ovld __cnfn convert_ulong2_rtp(half2);
+ulong2 __ovld __cnfn convert_ulong2_rtn(half2);
+ulong2 __ovld __cnfn convert_ulong2_rtz(half2);
+ulong2 __ovld __cnfn convert_ulong2_sat(half2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rte(half2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtp(half2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtn(half2);
+ulong2 __ovld __cnfn convert_ulong2_sat_rtz(half2);
+ulong3 __ovld __cnfn convert_ulong3(half3);
+ulong3 __ovld __cnfn convert_ulong3_rte(half3);
+ulong3 __ovld __cnfn convert_ulong3_rtp(half3);
+ulong3 __ovld __cnfn convert_ulong3_rtn(half3);
+ulong3 __ovld __cnfn convert_ulong3_rtz(half3);
+ulong3 __ovld __cnfn convert_ulong3_sat(half3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rte(half3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtp(half3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtn(half3);
+ulong3 __ovld __cnfn convert_ulong3_sat_rtz(half3);
+ulong4 __ovld __cnfn convert_ulong4(half4);
+ulong4 __ovld __cnfn convert_ulong4_rte(half4);
+ulong4 __ovld __cnfn convert_ulong4_rtp(half4);
+ulong4 __ovld __cnfn convert_ulong4_rtn(half4);
+ulong4 __ovld __cnfn convert_ulong4_rtz(half4);
+ulong4 __ovld __cnfn convert_ulong4_sat(half4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rte(half4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtp(half4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtn(half4);
+ulong4 __ovld __cnfn convert_ulong4_sat_rtz(half4);
+ulong8 __ovld __cnfn convert_ulong8(half8);
+ulong8 __ovld __cnfn convert_ulong8_rte(half8);
+ulong8 __ovld __cnfn convert_ulong8_rtp(half8);
+ulong8 __ovld __cnfn convert_ulong8_rtn(half8);
+ulong8 __ovld __cnfn convert_ulong8_rtz(half8);
+ulong8 __ovld __cnfn convert_ulong8_sat(half8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rte(half8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtp(half8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtn(half8);
+ulong8 __ovld __cnfn convert_ulong8_sat_rtz(half8);
+ulong16 __ovld __cnfn convert_ulong16(half16);
+ulong16 __ovld __cnfn convert_ulong16_rte(half16);
+ulong16 __ovld __cnfn convert_ulong16_rtp(half16);
+ulong16 __ovld __cnfn convert_ulong16_rtn(half16);
+ulong16 __ovld __cnfn convert_ulong16_rtz(half16);
+ulong16 __ovld __cnfn convert_ulong16_sat(half16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rte(half16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtp(half16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtn(half16);
+ulong16 __ovld __cnfn convert_ulong16_sat_rtz(half16);
+char __ovld __cnfn convert_char(half);
+char __ovld __cnfn convert_char_rte(half);
+char __ovld __cnfn convert_char_rtp(half);
+char __ovld __cnfn convert_char_rtn(half);
+char __ovld __cnfn convert_char_rtz(half);
+char __ovld __cnfn convert_char_sat(half);
+char __ovld __cnfn convert_char_sat_rte(half);
+char __ovld __cnfn convert_char_sat_rtp(half);
+char __ovld __cnfn convert_char_sat_rtn(half);
+char __ovld __cnfn convert_char_sat_rtz(half);
+char2 __ovld __cnfn convert_char2(half2);
+char2 __ovld __cnfn convert_char2_rte(half2);
+char2 __ovld __cnfn convert_char2_rtp(half2);
+char2 __ovld __cnfn convert_char2_rtn(half2);
+char2 __ovld __cnfn convert_char2_rtz(half2);
+char2 __ovld __cnfn convert_char2_sat(half2);
+char2 __ovld __cnfn convert_char2_sat_rte(half2);
+char2 __ovld __cnfn convert_char2_sat_rtp(half2);
+char2 __ovld __cnfn convert_char2_sat_rtn(half2);
+char2 __ovld __cnfn convert_char2_sat_rtz(half2);
+char3 __ovld __cnfn convert_char3(half3);
+char3 __ovld __cnfn convert_char3_rte(half3);
+char3 __ovld __cnfn convert_char3_rtp(half3);
+char3 __ovld __cnfn convert_char3_rtn(half3);
+char3 __ovld __cnfn convert_char3_rtz(half3);
+char3 __ovld __cnfn convert_char3_sat(half3);
+char3 __ovld __cnfn convert_char3_sat_rte(half3);
+char3 __ovld __cnfn convert_char3_sat_rtp(half3);
+char3 __ovld __cnfn convert_char3_sat_rtn(half3);
+char3 __ovld __cnfn convert_char3_sat_rtz(half3);
+char4 __ovld __cnfn convert_char4(half4);
+char4 __ovld __cnfn convert_char4_rte(half4);
+char4 __ovld __cnfn convert_char4_rtp(half4);
+char4 __ovld __cnfn convert_char4_rtn(half4);
+char4 __ovld __cnfn convert_char4_rtz(half4);
+char4 __ovld __cnfn convert_char4_sat(half4);
+char4 __ovld __cnfn convert_char4_sat_rte(half4);
+char4 __ovld __cnfn convert_char4_sat_rtp(half4);
+char4 __ovld __cnfn convert_char4_sat_rtn(half4);
+char4 __ovld __cnfn convert_char4_sat_rtz(half4);
+char8 __ovld __cnfn convert_char8(half8);
+char8 __ovld __cnfn convert_char8_rte(half8);
+char8 __ovld __cnfn convert_char8_rtp(half8);
+char8 __ovld __cnfn convert_char8_rtn(half8);
+char8 __ovld __cnfn convert_char8_rtz(half8);
+char8 __ovld __cnfn convert_char8_sat(half8);
+char8 __ovld __cnfn convert_char8_sat_rte(half8);
+char8 __ovld __cnfn convert_char8_sat_rtp(half8);
+char8 __ovld __cnfn convert_char8_sat_rtn(half8);
+char8 __ovld __cnfn convert_char8_sat_rtz(half8);
+char16 __ovld __cnfn convert_char16(half16);
+char16 __ovld __cnfn convert_char16_rte(half16);
+char16 __ovld __cnfn convert_char16_rtp(half16);
+char16 __ovld __cnfn convert_char16_rtn(half16);
+char16 __ovld __cnfn convert_char16_rtz(half16);
+char16 __ovld __cnfn convert_char16_sat(half16);
+char16 __ovld __cnfn convert_char16_sat_rte(half16);
+char16 __ovld __cnfn convert_char16_sat_rtp(half16);
+char16 __ovld __cnfn convert_char16_sat_rtn(half16);
+char16 __ovld __cnfn convert_char16_sat_rtz(half16);
+short __ovld __cnfn convert_short(half);
+short __ovld __cnfn convert_short_rte(half);
+short __ovld __cnfn convert_short_rtp(half);
+short __ovld __cnfn convert_short_rtn(half);
+short __ovld __cnfn convert_short_rtz(half);
+short __ovld __cnfn convert_short_sat(half);
+short __ovld __cnfn convert_short_sat_rte(half);
+short __ovld __cnfn convert_short_sat_rtp(half);
+short __ovld __cnfn convert_short_sat_rtn(half);
+short __ovld __cnfn convert_short_sat_rtz(half);
+short2 __ovld __cnfn convert_short2(half2);
+short2 __ovld __cnfn convert_short2_rte(half2);
+short2 __ovld __cnfn convert_short2_rtp(half2);
+short2 __ovld __cnfn convert_short2_rtn(half2);
+short2 __ovld __cnfn convert_short2_rtz(half2);
+short2 __ovld __cnfn convert_short2_sat(half2);
+short2 __ovld __cnfn convert_short2_sat_rte(half2);
+short2 __ovld __cnfn convert_short2_sat_rtp(half2);
+short2 __ovld __cnfn convert_short2_sat_rtn(half2);
+short2 __ovld __cnfn convert_short2_sat_rtz(half2);
+short3 __ovld __cnfn convert_short3(half3);
+short3 __ovld __cnfn convert_short3_rte(half3);
+short3 __ovld __cnfn convert_short3_rtp(half3);
+short3 __ovld __cnfn convert_short3_rtn(half3);
+short3 __ovld __cnfn convert_short3_rtz(half3);
+short3 __ovld __cnfn convert_short3_sat(half3);
+short3 __ovld __cnfn convert_short3_sat_rte(half3);
+short3 __ovld __cnfn convert_short3_sat_rtp(half3);
+short3 __ovld __cnfn convert_short3_sat_rtn(half3);
+short3 __ovld __cnfn convert_short3_sat_rtz(half3);
+short4 __ovld __cnfn convert_short4(half4);
+short4 __ovld __cnfn convert_short4_rte(half4);
+short4 __ovld __cnfn convert_short4_rtp(half4);
+short4 __ovld __cnfn convert_short4_rtn(half4);
+short4 __ovld __cnfn convert_short4_rtz(half4);
+short4 __ovld __cnfn convert_short4_sat(half4);
+short4 __ovld __cnfn convert_short4_sat_rte(half4);
+short4 __ovld __cnfn convert_short4_sat_rtp(half4);
+short4 __ovld __cnfn convert_short4_sat_rtn(half4);
+short4 __ovld __cnfn convert_short4_sat_rtz(half4);
+short8 __ovld __cnfn convert_short8(half8);
+short8 __ovld __cnfn convert_short8_rte(half8);
+short8 __ovld __cnfn convert_short8_rtp(half8);
+short8 __ovld __cnfn convert_short8_rtn(half8);
+short8 __ovld __cnfn convert_short8_rtz(half8);
+short8 __ovld __cnfn convert_short8_sat(half8);
+short8 __ovld __cnfn convert_short8_sat_rte(half8);
+short8 __ovld __cnfn convert_short8_sat_rtp(half8);
+short8 __ovld __cnfn convert_short8_sat_rtn(half8);
+short8 __ovld __cnfn convert_short8_sat_rtz(half8);
+short16 __ovld __cnfn convert_short16(half16);
+short16 __ovld __cnfn convert_short16_rte(half16);
+short16 __ovld __cnfn convert_short16_rtp(half16);
+short16 __ovld __cnfn convert_short16_rtn(half16);
+short16 __ovld __cnfn convert_short16_rtz(half16);
+short16 __ovld __cnfn convert_short16_sat(half16);
+short16 __ovld __cnfn convert_short16_sat_rte(half16);
+short16 __ovld __cnfn convert_short16_sat_rtp(half16);
+short16 __ovld __cnfn convert_short16_sat_rtn(half16);
+short16 __ovld __cnfn convert_short16_sat_rtz(half16);
+int __ovld __cnfn convert_int(half);
+int __ovld __cnfn convert_int_rte(half);
+int __ovld __cnfn convert_int_rtp(half);
+int __ovld __cnfn convert_int_rtn(half);
+int __ovld __cnfn convert_int_rtz(half);
+int __ovld __cnfn convert_int_sat(half);
+int __ovld __cnfn convert_int_sat_rte(half);
+int __ovld __cnfn convert_int_sat_rtp(half);
+int __ovld __cnfn convert_int_sat_rtn(half);
+int __ovld __cnfn convert_int_sat_rtz(half);
+int2 __ovld __cnfn convert_int2(half2);
+int2 __ovld __cnfn convert_int2_rte(half2);
+int2 __ovld __cnfn convert_int2_rtp(half2);
+int2 __ovld __cnfn convert_int2_rtn(half2);
+int2 __ovld __cnfn convert_int2_rtz(half2);
+int2 __ovld __cnfn convert_int2_sat(half2);
+int2 __ovld __cnfn convert_int2_sat_rte(half2);
+int2 __ovld __cnfn convert_int2_sat_rtp(half2);
+int2 __ovld __cnfn convert_int2_sat_rtn(half2);
+int2 __ovld __cnfn convert_int2_sat_rtz(half2);
+int3 __ovld __cnfn convert_int3(half3);
+int3 __ovld __cnfn convert_int3_rte(half3);
+int3 __ovld __cnfn convert_int3_rtp(half3);
+int3 __ovld __cnfn convert_int3_rtn(half3);
+int3 __ovld __cnfn convert_int3_rtz(half3);
+int3 __ovld __cnfn convert_int3_sat(half3);
+int3 __ovld __cnfn convert_int3_sat_rte(half3);
+int3 __ovld __cnfn convert_int3_sat_rtp(half3);
+int3 __ovld __cnfn convert_int3_sat_rtn(half3);
+int3 __ovld __cnfn convert_int3_sat_rtz(half3);
+int4 __ovld __cnfn convert_int4(half4);
+int4 __ovld __cnfn convert_int4_rte(half4);
+int4 __ovld __cnfn convert_int4_rtp(half4);
+int4 __ovld __cnfn convert_int4_rtn(half4);
+int4 __ovld __cnfn convert_int4_rtz(half4);
+int4 __ovld __cnfn convert_int4_sat(half4);
+int4 __ovld __cnfn convert_int4_sat_rte(half4);
+int4 __ovld __cnfn convert_int4_sat_rtp(half4);
+int4 __ovld __cnfn convert_int4_sat_rtn(half4);
+int4 __ovld __cnfn convert_int4_sat_rtz(half4);
+int8 __ovld __cnfn convert_int8(half8);
+int8 __ovld __cnfn convert_int8_rte(half8);
+int8 __ovld __cnfn convert_int8_rtp(half8);
+int8 __ovld __cnfn convert_int8_rtn(half8);
+int8 __ovld __cnfn convert_int8_rtz(half8);
+int8 __ovld __cnfn convert_int8_sat(half8);
+int8 __ovld __cnfn convert_int8_sat_rte(half8);
+int8 __ovld __cnfn convert_int8_sat_rtp(half8);
+int8 __ovld __cnfn convert_int8_sat_rtn(half8);
+int8 __ovld __cnfn convert_int8_sat_rtz(half8);
+int16 __ovld __cnfn convert_int16(half16);
+int16 __ovld __cnfn convert_int16_rte(half16);
+int16 __ovld __cnfn convert_int16_rtp(half16);
+int16 __ovld __cnfn convert_int16_rtn(half16);
+int16 __ovld __cnfn convert_int16_rtz(half16);
+int16 __ovld __cnfn convert_int16_sat(half16);
+int16 __ovld __cnfn convert_int16_sat_rte(half16);
+int16 __ovld __cnfn convert_int16_sat_rtp(half16);
+int16 __ovld __cnfn convert_int16_sat_rtn(half16);
+int16 __ovld __cnfn convert_int16_sat_rtz(half16);
+long __ovld __cnfn convert_long(half);
+long __ovld __cnfn convert_long_rte(half);
+long __ovld __cnfn convert_long_rtp(half);
+long __ovld __cnfn convert_long_rtn(half);
+long __ovld __cnfn convert_long_rtz(half);
+long __ovld __cnfn convert_long_sat(half);
+long __ovld __cnfn convert_long_sat_rte(half);
+long __ovld __cnfn convert_long_sat_rtp(half);
+long __ovld __cnfn convert_long_sat_rtn(half);
+long __ovld __cnfn convert_long_sat_rtz(half);
+long2 __ovld __cnfn convert_long2(half2);
+long2 __ovld __cnfn convert_long2_rte(half2);
+long2 __ovld __cnfn convert_long2_rtp(half2);
+long2 __ovld __cnfn convert_long2_rtn(half2);
+long2 __ovld __cnfn convert_long2_rtz(half2);
+long2 __ovld __cnfn convert_long2_sat(half2);
+long2 __ovld __cnfn convert_long2_sat_rte(half2);
+long2 __ovld __cnfn convert_long2_sat_rtp(half2);
+long2 __ovld __cnfn convert_long2_sat_rtn(half2);
+long2 __ovld __cnfn convert_long2_sat_rtz(half2);
+long3 __ovld __cnfn convert_long3(half3);
+long3 __ovld __cnfn convert_long3_rte(half3);
+long3 __ovld __cnfn convert_long3_rtp(half3);
+long3 __ovld __cnfn convert_long3_rtn(half3);
+long3 __ovld __cnfn convert_long3_rtz(half3);
+long3 __ovld __cnfn convert_long3_sat(half3);
+long3 __ovld __cnfn convert_long3_sat_rte(half3);
+long3 __ovld __cnfn convert_long3_sat_rtp(half3);
+long3 __ovld __cnfn convert_long3_sat_rtn(half3);
+long3 __ovld __cnfn convert_long3_sat_rtz(half3);
+long4 __ovld __cnfn convert_long4(half4);
+long4 __ovld __cnfn convert_long4_rte(half4);
+long4 __ovld __cnfn convert_long4_rtp(half4);
+long4 __ovld __cnfn convert_long4_rtn(half4);
+long4 __ovld __cnfn convert_long4_rtz(half4);
+long4 __ovld __cnfn convert_long4_sat(half4);
+long4 __ovld __cnfn convert_long4_sat_rte(half4);
+long4 __ovld __cnfn convert_long4_sat_rtp(half4);
+long4 __ovld __cnfn convert_long4_sat_rtn(half4);
+long4 __ovld __cnfn convert_long4_sat_rtz(half4);
+long8 __ovld __cnfn convert_long8(half8);
+long8 __ovld __cnfn convert_long8_rte(half8);
+long8 __ovld __cnfn convert_long8_rtp(half8);
+long8 __ovld __cnfn convert_long8_rtn(half8);
+long8 __ovld __cnfn convert_long8_rtz(half8);
+long8 __ovld __cnfn convert_long8_sat(half8);
+long8 __ovld __cnfn convert_long8_sat_rte(half8);
+long8 __ovld __cnfn convert_long8_sat_rtp(half8);
+long8 __ovld __cnfn convert_long8_sat_rtn(half8);
+long8 __ovld __cnfn convert_long8_sat_rtz(half8);
+long16 __ovld __cnfn convert_long16(half16);
+long16 __ovld __cnfn convert_long16_rte(half16);
+long16 __ovld __cnfn convert_long16_rtp(half16);
+long16 __ovld __cnfn convert_long16_rtn(half16);
+long16 __ovld __cnfn convert_long16_rtz(half16);
+long16 __ovld __cnfn convert_long16_sat(half16);
+long16 __ovld __cnfn convert_long16_sat_rte(half16);
+long16 __ovld __cnfn convert_long16_sat_rtp(half16);
+long16 __ovld __cnfn convert_long16_sat_rtn(half16);
+long16 __ovld __cnfn convert_long16_sat_rtz(half16);
+float __ovld __cnfn convert_float(half);
+float __ovld __cnfn convert_float_rte(half);
+float __ovld __cnfn convert_float_rtp(half);
+float __ovld __cnfn convert_float_rtn(half);
+float __ovld __cnfn convert_float_rtz(half);
+float2 __ovld __cnfn convert_float2(half2);
+float2 __ovld __cnfn convert_float2_rte(half2);
+float2 __ovld __cnfn convert_float2_rtp(half2);
+float2 __ovld __cnfn convert_float2_rtn(half2);
+float2 __ovld __cnfn convert_float2_rtz(half2);
+float3 __ovld __cnfn convert_float3(half3);
+float3 __ovld __cnfn convert_float3_rte(half3);
+float3 __ovld __cnfn convert_float3_rtp(half3);
+float3 __ovld __cnfn convert_float3_rtn(half3);
+float3 __ovld __cnfn convert_float3_rtz(half3);
+float4 __ovld __cnfn convert_float4(half4);
+float4 __ovld __cnfn convert_float4_rte(half4);
+float4 __ovld __cnfn convert_float4_rtp(half4);
+float4 __ovld __cnfn convert_float4_rtn(half4);
+float4 __ovld __cnfn convert_float4_rtz(half4);
+float8 __ovld __cnfn convert_float8(half8);
+float8 __ovld __cnfn convert_float8_rte(half8);
+float8 __ovld __cnfn convert_float8_rtp(half8);
+float8 __ovld __cnfn convert_float8_rtn(half8);
+float8 __ovld __cnfn convert_float8_rtz(half8);
+float16 __ovld __cnfn convert_float16(half16);
+float16 __ovld __cnfn convert_float16_rte(half16);
+float16 __ovld __cnfn convert_float16_rtp(half16);
+float16 __ovld __cnfn convert_float16_rtn(half16);
+float16 __ovld __cnfn convert_float16_rtz(half16);
+
+// Convert non-double types to half types.
+half __ovld __cnfn convert_half(uchar);
+half __ovld __cnfn convert_half(ushort);
+half __ovld __cnfn convert_half(uint);
+half __ovld __cnfn convert_half(ulong);
+half __ovld __cnfn convert_half(char);
+half __ovld __cnfn convert_half(short);
+half __ovld __cnfn convert_half(int);
+half __ovld __cnfn convert_half(long);
+half __ovld __cnfn convert_half(float);
+half __ovld __cnfn convert_half(half);
+half __ovld __cnfn convert_half_rte(uchar);
+half __ovld __cnfn convert_half_rte(ushort);
+half __ovld __cnfn convert_half_rte(uint);
+half __ovld __cnfn convert_half_rte(ulong);
+half __ovld __cnfn convert_half_rte(char);
+half __ovld __cnfn convert_half_rte(short);
+half __ovld __cnfn convert_half_rte(int);
+half __ovld __cnfn convert_half_rte(long);
+half __ovld __cnfn convert_half_rte(float);
+half __ovld __cnfn convert_half_rte(half);
+half __ovld __cnfn convert_half_rtp(uchar);
+half __ovld __cnfn convert_half_rtp(ushort);
+half __ovld __cnfn convert_half_rtp(uint);
+half __ovld __cnfn convert_half_rtp(ulong);
+half __ovld __cnfn convert_half_rtp(char);
+half __ovld __cnfn convert_half_rtp(short);
+half __ovld __cnfn convert_half_rtp(int);
+half __ovld __cnfn convert_half_rtp(long);
+half __ovld __cnfn convert_half_rtp(float);
+half __ovld __cnfn convert_half_rtp(half);
+half __ovld __cnfn convert_half_rtn(uchar);
+half __ovld __cnfn convert_half_rtn(ushort);
+half __ovld __cnfn convert_half_rtn(uint);
+half __ovld __cnfn convert_half_rtn(ulong);
+half __ovld __cnfn convert_half_rtn(char);
+half __ovld __cnfn convert_half_rtn(short);
+half __ovld __cnfn convert_half_rtn(int);
+half __ovld __cnfn convert_half_rtn(long);
+half __ovld __cnfn convert_half_rtn(float);
+half __ovld __cnfn convert_half_rtn(half);
+half __ovld __cnfn convert_half_rtz(uchar);
+half __ovld __cnfn convert_half_rtz(ushort);
+half __ovld __cnfn convert_half_rtz(uint);
+half __ovld __cnfn convert_half_rtz(ulong);
+half __ovld __cnfn convert_half_rtz(char);
+half __ovld __cnfn convert_half_rtz(short);
+half __ovld __cnfn convert_half_rtz(int);
+half __ovld __cnfn convert_half_rtz(long);
+half __ovld __cnfn convert_half_rtz(float);
+half __ovld __cnfn convert_half_rtz(half);
+half2 __ovld __cnfn convert_half2(char2);
+half2 __ovld __cnfn convert_half2(uchar2);
+half2 __ovld __cnfn convert_half2(short2);
+half2 __ovld __cnfn convert_half2(ushort2);
+half2 __ovld __cnfn convert_half2(int2);
+half2 __ovld __cnfn convert_half2(uint2);
+half2 __ovld __cnfn convert_half2(long2);
+half2 __ovld __cnfn convert_half2(ulong2);
+half2 __ovld __cnfn convert_half2(float2);
+half2 __ovld __cnfn convert_half2(half2);
+half2 __ovld __cnfn convert_half2_rte(char2);
+half2 __ovld __cnfn convert_half2_rte(uchar2);
+half2 __ovld __cnfn convert_half2_rte(short2);
+half2 __ovld __cnfn convert_half2_rte(ushort2);
+half2 __ovld __cnfn convert_half2_rte(int2);
+half2 __ovld __cnfn convert_half2_rte(uint2);
+half2 __ovld __cnfn convert_half2_rte(long2);
+half2 __ovld __cnfn convert_half2_rte(ulong2);
+half2 __ovld __cnfn convert_half2_rte(float2);
+half2 __ovld __cnfn convert_half2_rte(half2);
+half2 __ovld __cnfn convert_half2_rtp(char2);
+half2 __ovld __cnfn convert_half2_rtp(uchar2);
+half2 __ovld __cnfn convert_half2_rtp(short2);
+half2 __ovld __cnfn convert_half2_rtp(ushort2);
+half2 __ovld __cnfn convert_half2_rtp(int2);
+half2 __ovld __cnfn convert_half2_rtp(uint2);
+half2 __ovld __cnfn convert_half2_rtp(long2);
+half2 __ovld __cnfn convert_half2_rtp(ulong2);
+half2 __ovld __cnfn convert_half2_rtp(float2);
+half2 __ovld __cnfn convert_half2_rtp(half2);
+half2 __ovld __cnfn convert_half2_rtn(char2);
+half2 __ovld __cnfn convert_half2_rtn(uchar2);
+half2 __ovld __cnfn convert_half2_rtn(short2);
+half2 __ovld __cnfn convert_half2_rtn(ushort2);
+half2 __ovld __cnfn convert_half2_rtn(int2);
+half2 __ovld __cnfn convert_half2_rtn(uint2);
+half2 __ovld __cnfn convert_half2_rtn(long2);
+half2 __ovld __cnfn convert_half2_rtn(ulong2);
+half2 __ovld __cnfn convert_half2_rtn(float2);
+half2 __ovld __cnfn convert_half2_rtn(half2);
+half2 __ovld __cnfn convert_half2_rtz(char2);
+half2 __ovld __cnfn convert_half2_rtz(uchar2);
+half2 __ovld __cnfn convert_half2_rtz(short2);
+half2 __ovld __cnfn convert_half2_rtz(ushort2);
+half2 __ovld __cnfn convert_half2_rtz(int2);
+half2 __ovld __cnfn convert_half2_rtz(uint2);
+half2 __ovld __cnfn convert_half2_rtz(long2);
+half2 __ovld __cnfn convert_half2_rtz(ulong2);
+half2 __ovld __cnfn convert_half2_rtz(float2);
+half2 __ovld __cnfn convert_half2_rtz(half2);
+half3 __ovld __cnfn convert_half3(char3);
+half3 __ovld __cnfn convert_half3(uchar3);
+half3 __ovld __cnfn convert_half3(short3);
+half3 __ovld __cnfn convert_half3(ushort3);
+half3 __ovld __cnfn convert_half3(int3);
+half3 __ovld __cnfn convert_half3(uint3);
+half3 __ovld __cnfn convert_half3(long3);
+half3 __ovld __cnfn convert_half3(ulong3);
+half3 __ovld __cnfn convert_half3(float3);
+half3 __ovld __cnfn convert_half3(half3);
+half3 __ovld __cnfn convert_half3_rte(char3);
+half3 __ovld __cnfn convert_half3_rte(uchar3);
+half3 __ovld __cnfn convert_half3_rte(short3);
+half3 __ovld __cnfn convert_half3_rte(ushort3);
+half3 __ovld __cnfn convert_half3_rte(int3);
+half3 __ovld __cnfn convert_half3_rte(uint3);
+half3 __ovld __cnfn convert_half3_rte(long3);
+half3 __ovld __cnfn convert_half3_rte(ulong3);
+half3 __ovld __cnfn convert_half3_rte(float3);
+half3 __ovld __cnfn convert_half3_rte(half3);
+half3 __ovld __cnfn convert_half3_rtp(char3);
+half3 __ovld __cnfn convert_half3_rtp(uchar3);
+half3 __ovld __cnfn convert_half3_rtp(short3);
+half3 __ovld __cnfn convert_half3_rtp(ushort3);
+half3 __ovld __cnfn convert_half3_rtp(int3);
+half3 __ovld __cnfn convert_half3_rtp(uint3);
+half3 __ovld __cnfn convert_half3_rtp(long3);
+half3 __ovld __cnfn convert_half3_rtp(ulong3);
+half3 __ovld __cnfn convert_half3_rtp(float3);
+half3 __ovld __cnfn convert_half3_rtp(half3);
+half3 __ovld __cnfn convert_half3_rtn(char3);
+half3 __ovld __cnfn convert_half3_rtn(uchar3);
+half3 __ovld __cnfn convert_half3_rtn(short3);
+half3 __ovld __cnfn convert_half3_rtn(ushort3);
+half3 __ovld __cnfn convert_half3_rtn(int3);
+half3 __ovld __cnfn convert_half3_rtn(uint3);
+half3 __ovld __cnfn convert_half3_rtn(long3);
+half3 __ovld __cnfn convert_half3_rtn(ulong3);
+half3 __ovld __cnfn convert_half3_rtn(float3);
+half3 __ovld __cnfn convert_half3_rtn(half3);
+half3 __ovld __cnfn convert_half3_rtz(char3);
+half3 __ovld __cnfn convert_half3_rtz(uchar3);
+half3 __ovld __cnfn convert_half3_rtz(short3);
+half3 __ovld __cnfn convert_half3_rtz(ushort3);
+half3 __ovld __cnfn convert_half3_rtz(int3);
+half3 __ovld __cnfn convert_half3_rtz(uint3);
+half3 __ovld __cnfn convert_half3_rtz(long3);
+half3 __ovld __cnfn convert_half3_rtz(ulong3);
+half3 __ovld __cnfn convert_half3_rtz(float3);
+half3 __ovld __cnfn convert_half3_rtz(half3);
+half4 __ovld __cnfn convert_half4(char4);
+half4 __ovld __cnfn convert_half4(uchar4);
+half4 __ovld __cnfn convert_half4(short4);
+half4 __ovld __cnfn convert_half4(ushort4);
+half4 __ovld __cnfn convert_half4(int4);
+half4 __ovld __cnfn convert_half4(uint4);
+half4 __ovld __cnfn convert_half4(long4);
+half4 __ovld __cnfn convert_half4(ulong4);
+half4 __ovld __cnfn convert_half4(float4);
+half4 __ovld __cnfn convert_half4(half4);
+half4 __ovld __cnfn convert_half4_rte(char4);
+half4 __ovld __cnfn convert_half4_rte(uchar4);
+half4 __ovld __cnfn convert_half4_rte(short4);
+half4 __ovld __cnfn convert_half4_rte(ushort4);
+half4 __ovld __cnfn convert_half4_rte(int4);
+half4 __ovld __cnfn convert_half4_rte(uint4);
+half4 __ovld __cnfn convert_half4_rte(long4);
+half4 __ovld __cnfn convert_half4_rte(ulong4);
+half4 __ovld __cnfn convert_half4_rte(float4);
+half4 __ovld __cnfn convert_half4_rte(half4);
+half4 __ovld __cnfn convert_half4_rtp(char4);
+half4 __ovld __cnfn convert_half4_rtp(uchar4);
+half4 __ovld __cnfn convert_half4_rtp(short4);
+half4 __ovld __cnfn convert_half4_rtp(ushort4);
+half4 __ovld __cnfn convert_half4_rtp(int4);
+half4 __ovld __cnfn convert_half4_rtp(uint4);
+half4 __ovld __cnfn convert_half4_rtp(long4);
+half4 __ovld __cnfn convert_half4_rtp(ulong4);
+half4 __ovld __cnfn convert_half4_rtp(float4);
+half4 __ovld __cnfn convert_half4_rtp(half4);
+half4 __ovld __cnfn convert_half4_rtn(char4);
+half4 __ovld __cnfn convert_half4_rtn(uchar4);
+half4 __ovld __cnfn convert_half4_rtn(short4);
+half4 __ovld __cnfn convert_half4_rtn(ushort4);
+half4 __ovld __cnfn convert_half4_rtn(int4);
+half4 __ovld __cnfn convert_half4_rtn(uint4);
+half4 __ovld __cnfn convert_half4_rtn(long4);
+half4 __ovld __cnfn convert_half4_rtn(ulong4);
+half4 __ovld __cnfn convert_half4_rtn(float4);
+half4 __ovld __cnfn convert_half4_rtn(half4);
+half4 __ovld __cnfn convert_half4_rtz(char4);
+half4 __ovld __cnfn convert_half4_rtz(uchar4);
+half4 __ovld __cnfn convert_half4_rtz(short4);
+half4 __ovld __cnfn convert_half4_rtz(ushort4);
+half4 __ovld __cnfn convert_half4_rtz(int4);
+half4 __ovld __cnfn convert_half4_rtz(uint4);
+half4 __ovld __cnfn convert_half4_rtz(long4);
+half4 __ovld __cnfn convert_half4_rtz(ulong4);
+half4 __ovld __cnfn convert_half4_rtz(float4);
+half4 __ovld __cnfn convert_half4_rtz(half4);
+half8 __ovld __cnfn convert_half8(char8);
+half8 __ovld __cnfn convert_half8(uchar8);
+half8 __ovld __cnfn convert_half8(short8);
+half8 __ovld __cnfn convert_half8(ushort8);
+half8 __ovld __cnfn convert_half8(int8);
+half8 __ovld __cnfn convert_half8(uint8);
+half8 __ovld __cnfn convert_half8(long8);
+half8 __ovld __cnfn convert_half8(ulong8);
+half8 __ovld __cnfn convert_half8(float8);
+half8 __ovld __cnfn convert_half8(half8);
+half8 __ovld __cnfn convert_half8_rte(char8);
+half8 __ovld __cnfn convert_half8_rte(uchar8);
+half8 __ovld __cnfn convert_half8_rte(short8);
+half8 __ovld __cnfn convert_half8_rte(ushort8);
+half8 __ovld __cnfn convert_half8_rte(int8);
+half8 __ovld __cnfn convert_half8_rte(uint8);
+half8 __ovld __cnfn convert_half8_rte(long8);
+half8 __ovld __cnfn convert_half8_rte(ulong8);
+half8 __ovld __cnfn convert_half8_rte(float8);
+half8 __ovld __cnfn convert_half8_rte(half8);
+half8 __ovld __cnfn convert_half8_rtp(char8);
+half8 __ovld __cnfn convert_half8_rtp(uchar8);
+half8 __ovld __cnfn convert_half8_rtp(short8);
+half8 __ovld __cnfn convert_half8_rtp(ushort8);
+half8 __ovld __cnfn convert_half8_rtp(int8);
+half8 __ovld __cnfn convert_half8_rtp(uint8);
+half8 __ovld __cnfn convert_half8_rtp(long8);
+half8 __ovld __cnfn convert_half8_rtp(ulong8);
+half8 __ovld __cnfn convert_half8_rtp(float8);
+half8 __ovld __cnfn convert_half8_rtp(half8);
+half8 __ovld __cnfn convert_half8_rtn(char8);
+half8 __ovld __cnfn convert_half8_rtn(uchar8);
+half8 __ovld __cnfn convert_half8_rtn(short8);
+half8 __ovld __cnfn convert_half8_rtn(ushort8);
+half8 __ovld __cnfn convert_half8_rtn(int8);
+half8 __ovld __cnfn convert_half8_rtn(uint8);
+half8 __ovld __cnfn convert_half8_rtn(long8);
+half8 __ovld __cnfn convert_half8_rtn(ulong8);
+half8 __ovld __cnfn convert_half8_rtn(float8);
+half8 __ovld __cnfn convert_half8_rtn(half8);
+half8 __ovld __cnfn convert_half8_rtz(char8);
+half8 __ovld __cnfn convert_half8_rtz(uchar8);
+half8 __ovld __cnfn convert_half8_rtz(short8);
+half8 __ovld __cnfn convert_half8_rtz(ushort8);
+half8 __ovld __cnfn convert_half8_rtz(int8);
+half8 __ovld __cnfn convert_half8_rtz(uint8);
+half8 __ovld __cnfn convert_half8_rtz(long8);
+half8 __ovld __cnfn convert_half8_rtz(ulong8);
+half8 __ovld __cnfn convert_half8_rtz(float8);
+half8 __ovld __cnfn convert_half8_rtz(half8);
+half16 __ovld __cnfn convert_half16(char16);
+half16 __ovld __cnfn convert_half16(uchar16);
+half16 __ovld __cnfn convert_half16(short16);
+half16 __ovld __cnfn convert_half16(ushort16);
+half16 __ovld __cnfn convert_half16(int16);
+half16 __ovld __cnfn convert_half16(uint16);
+half16 __ovld __cnfn convert_half16(long16);
+half16 __ovld __cnfn convert_half16(ulong16);
+half16 __ovld __cnfn convert_half16(float16);
+half16 __ovld __cnfn convert_half16(half16);
+half16 __ovld __cnfn convert_half16_rte(char16);
+half16 __ovld __cnfn convert_half16_rte(uchar16);
+half16 __ovld __cnfn convert_half16_rte(short16);
+half16 __ovld __cnfn convert_half16_rte(ushort16);
+half16 __ovld __cnfn convert_half16_rte(int16);
+half16 __ovld __cnfn convert_half16_rte(uint16);
+half16 __ovld __cnfn convert_half16_rte(long16);
+half16 __ovld __cnfn convert_half16_rte(ulong16);
+half16 __ovld __cnfn convert_half16_rte(float16);
+half16 __ovld __cnfn convert_half16_rte(half16);
+half16 __ovld __cnfn convert_half16_rtp(char16);
+half16 __ovld __cnfn convert_half16_rtp(uchar16);
+half16 __ovld __cnfn convert_half16_rtp(short16);
+half16 __ovld __cnfn convert_half16_rtp(ushort16);
+half16 __ovld __cnfn convert_half16_rtp(int16);
+half16 __ovld __cnfn convert_half16_rtp(uint16);
+half16 __ovld __cnfn convert_half16_rtp(long16);
+half16 __ovld __cnfn convert_half16_rtp(ulong16);
+half16 __ovld __cnfn convert_half16_rtp(float16);
+half16 __ovld __cnfn convert_half16_rtp(half16);
+half16 __ovld __cnfn convert_half16_rtn(char16);
+half16 __ovld __cnfn convert_half16_rtn(uchar16);
+half16 __ovld __cnfn convert_half16_rtn(short16);
+half16 __ovld __cnfn convert_half16_rtn(ushort16);
+half16 __ovld __cnfn convert_half16_rtn(int16);
+half16 __ovld __cnfn convert_half16_rtn(uint16);
+half16 __ovld __cnfn convert_half16_rtn(long16);
+half16 __ovld __cnfn convert_half16_rtn(ulong16);
+half16 __ovld __cnfn convert_half16_rtn(float16);
+half16 __ovld __cnfn convert_half16_rtn(half16);
+half16 __ovld __cnfn convert_half16_rtz(char16);
+half16 __ovld __cnfn convert_half16_rtz(uchar16);
+half16 __ovld __cnfn convert_half16_rtz(short16);
+half16 __ovld __cnfn convert_half16_rtz(ushort16);
+half16 __ovld __cnfn convert_half16_rtz(int16);
+half16 __ovld __cnfn convert_half16_rtz(uint16);
+half16 __ovld __cnfn convert_half16_rtz(long16);
+half16 __ovld __cnfn convert_half16_rtz(ulong16);
+half16 __ovld __cnfn convert_half16_rtz(float16);
+half16 __ovld __cnfn convert_half16_rtz(half16);
+
+// Convert half types to double types.
+#ifdef cl_khr_fp64
+double __ovld __cnfn convert_double(half);
+double __ovld __cnfn convert_double_rte(half);
+double __ovld __cnfn convert_double_rtp(half);
+double __ovld __cnfn convert_double_rtn(half);
+double __ovld __cnfn convert_double_rtz(half);
+double2 __ovld __cnfn convert_double2(half2);
+double2 __ovld __cnfn convert_double2_rte(half2);
+double2 __ovld __cnfn convert_double2_rtp(half2);
+double2 __ovld __cnfn convert_double2_rtn(half2);
+double2 __ovld __cnfn convert_double2_rtz(half2);
+double3 __ovld __cnfn convert_double3(half3);
+double3 __ovld __cnfn convert_double3_rte(half3);
+double3 __ovld __cnfn convert_double3_rtp(half3);
+double3 __ovld __cnfn convert_double3_rtn(half3);
+double3 __ovld __cnfn convert_double3_rtz(half3);
+double4 __ovld __cnfn convert_double4(half4);
+double4 __ovld __cnfn convert_double4_rte(half4);
+double4 __ovld __cnfn convert_double4_rtp(half4);
+double4 __ovld __cnfn convert_double4_rtn(half4);
+double4 __ovld __cnfn convert_double4_rtz(half4);
+double8 __ovld __cnfn convert_double8(half8);
+double8 __ovld __cnfn convert_double8_rte(half8);
+double8 __ovld __cnfn convert_double8_rtp(half8);
+double8 __ovld __cnfn convert_double8_rtn(half8);
+double8 __ovld __cnfn convert_double8_rtz(half8);
+double16 __ovld __cnfn convert_double16(half16);
+double16 __ovld __cnfn convert_double16_rte(half16);
+double16 __ovld __cnfn convert_double16_rtp(half16);
+double16 __ovld __cnfn convert_double16_rtn(half16);
+double16 __ovld __cnfn convert_double16_rtz(half16);
+
+// Convert double types to half types.
+half __ovld __cnfn convert_half(double);
+half __ovld __cnfn convert_half_rte(double);
+half __ovld __cnfn convert_half_rtp(double);
+half __ovld __cnfn convert_half_rtn(double);
+half __ovld __cnfn convert_half_rtz(double);
+half2 __ovld __cnfn convert_half2(double2);
+half2 __ovld __cnfn convert_half2_rte(double2);
+half2 __ovld __cnfn convert_half2_rtp(double2);
+half2 __ovld __cnfn convert_half2_rtn(double2);
+half2 __ovld __cnfn convert_half2_rtz(double2);
+half3 __ovld __cnfn convert_half3(double3);
+half3 __ovld __cnfn convert_half3_rte(double3);
+half3 __ovld __cnfn convert_half3_rtp(double3);
+half3 __ovld __cnfn convert_half3_rtn(double3);
+half3 __ovld __cnfn convert_half3_rtz(double3);
+half4 __ovld __cnfn convert_half4(double4);
+half4 __ovld __cnfn convert_half4_rte(double4);
+half4 __ovld __cnfn convert_half4_rtp(double4);
+half4 __ovld __cnfn convert_half4_rtn(double4);
+half4 __ovld __cnfn convert_half4_rtz(double4);
+half8 __ovld __cnfn convert_half8(double8);
+half8 __ovld __cnfn convert_half8_rte(double8);
+half8 __ovld __cnfn convert_half8_rtp(double8);
+half8 __ovld __cnfn convert_half8_rtn(double8);
+half8 __ovld __cnfn convert_half8_rtz(double8);
+half16 __ovld __cnfn convert_half16(double16);
+half16 __ovld __cnfn convert_half16_rte(double16);
+half16 __ovld __cnfn convert_half16_rtp(double16);
+half16 __ovld __cnfn convert_half16_rtn(double16);
+half16 __ovld __cnfn convert_half16_rtz(double16);
+#endif //cl_khr_fp64
+
+#endif // cl_khr_fp16
+
+// OpenCL v1.1 s6.11.1, v1.2 s6.12.1, v2.0 s6.13.1 - Work-item Functions
+
+/**
+ * Returns the number of dimensions in use. This is the
+ * value given to the work_dim argument specified in
+ * clEnqueueNDRangeKernel.
+ * For clEnqueueTask, this returns 1.
+ */
+uint __ovld __cnfn get_work_dim(void);
+
+/**
+ * Returns the number of global work-items specified for
+ * dimension identified by dimindx. This value is given by
+ * the global_work_size argument to
+ * clEnqueueNDRangeKernel. Valid values of dimindx
+ * are 0 to get_work_dim() - 1. For other values of
+ * dimindx, get_global_size() returns 1.
+ * For clEnqueueTask, this always returns 1.
+ */
+size_t __ovld __cnfn get_global_size(uint);
+
+/**
+ * Returns the unique global work-item ID value for
+ * dimension identified by dimindx. The global work-item
+ * ID specifies the work-item ID based on the number of
+ * global work-items specified to execute the kernel. Valid
+ * values of dimindx are 0 to get_work_dim() - 1. For
+ * other values of dimindx, get_global_id() returns 0.
+ * For clEnqueueTask, this returns 0.
+ */
+size_t __ovld __cnfn get_global_id(uint);
+
+/**
+ * Returns the number of local work-items specified in
+ * dimension identified by dimindx. This value is given by
+ * the local_work_size argument to
+ * clEnqueueNDRangeKernel if local_work_size is not
+ * NULL; otherwise the OpenCL implementation chooses
+ * an appropriate local_work_size value which is returned
+ * by this function. Valid values of dimindx are 0 to
+ * get_work_dim() - 1. For other values of dimindx,
+ * get_local_size() returns 1.
+ * For clEnqueueTask, this always returns 1.
+ */
+size_t __ovld __cnfn get_local_size(uint);
+
+/**
+ * Returns the unique local work-item ID i.e. a work-item
+ * within a specific work-group for dimension identified by
+ * dimindx. Valid values of dimindx are 0 to
+ * get_work_dim() - 1. For other values of dimindx,
+ * get_local_id() returns 0.
+ * For clEnqueueTask, this returns 0.
+ */
+size_t __ovld __cnfn get_local_id(uint);
+
+/**
+ * Returns the number of work-groups that will execute a
+ * kernel for dimension identified by dimindx.
+ * Valid values of dimindx are 0 to get_work_dim() - 1.
+ * For other values of dimindx, get_num_groups() returns 1.
+ * For clEnqueueTask, this always returns 1.
+ */
+size_t __ovld __cnfn get_num_groups(uint);
+
+/**
+ * get_group_id returns the work-group ID which is a
+ * number from 0 .. get_num_groups(dimindx) - 1.
+ * Valid values of dimindx are 0 to get_work_dim() - 1.
+ * For other values, get_group_id() returns 0.
+ * For clEnqueueTask, this returns 0.
+ */
+size_t __ovld __cnfn get_group_id(uint);
+
+/**
+ * get_global_offset returns the offset values specified in
+ * global_work_offset argument to
+ * clEnqueueNDRangeKernel.
+ * Valid values of dimindx are 0 to get_work_dim() - 1.
+ * For other values, get_global_offset() returns 0.
+ * For clEnqueueTask, this returns 0.
+ */
+size_t __ovld __cnfn get_global_offset(uint);
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+size_t __ovld get_enqueued_local_size(uint);
+size_t __ovld get_global_linear_id(void);
+size_t __ovld get_local_linear_id(void);
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// OpenCL v1.1 s6.11.2, v1.2 s6.12.2, v2.0 s6.13.2 - Math functions
+
+/**
+ * Arc cosine function.
+ */
+float __ovld __cnfn acos(float);
+float2 __ovld __cnfn acos(float2);
+float3 __ovld __cnfn acos(float3);
+float4 __ovld __cnfn acos(float4);
+float8 __ovld __cnfn acos(float8);
+float16 __ovld __cnfn acos(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn acos(double);
+double2 __ovld __cnfn acos(double2);
+double3 __ovld __cnfn acos(double3);
+double4 __ovld __cnfn acos(double4);
+double8 __ovld __cnfn acos(double8);
+double16 __ovld __cnfn acos(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn acos(half);
+half2 __ovld __cnfn acos(half2);
+half3 __ovld __cnfn acos(half3);
+half4 __ovld __cnfn acos(half4);
+half8 __ovld __cnfn acos(half8);
+half16 __ovld __cnfn acos(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Inverse hyperbolic cosine.
+ */
+float __ovld __cnfn acosh(float);
+float2 __ovld __cnfn acosh(float2);
+float3 __ovld __cnfn acosh(float3);
+float4 __ovld __cnfn acosh(float4);
+float8 __ovld __cnfn acosh(float8);
+float16 __ovld __cnfn acosh(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn acosh(double);
+double2 __ovld __cnfn acosh(double2);
+double3 __ovld __cnfn acosh(double3);
+double4 __ovld __cnfn acosh(double4);
+double8 __ovld __cnfn acosh(double8);
+double16 __ovld __cnfn acosh(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn acosh(half);
+half2 __ovld __cnfn acosh(half2);
+half3 __ovld __cnfn acosh(half3);
+half4 __ovld __cnfn acosh(half4);
+half8 __ovld __cnfn acosh(half8);
+half16 __ovld __cnfn acosh(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute acos (x) / PI.
+ */
+float __ovld __cnfn acospi(float);
+float2 __ovld __cnfn acospi(float2);
+float3 __ovld __cnfn acospi(float3);
+float4 __ovld __cnfn acospi(float4);
+float8 __ovld __cnfn acospi(float8);
+float16 __ovld __cnfn acospi(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn acospi(double);
+double2 __ovld __cnfn acospi(double2);
+double3 __ovld __cnfn acospi(double3);
+double4 __ovld __cnfn acospi(double4);
+double8 __ovld __cnfn acospi(double8);
+double16 __ovld __cnfn acospi(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn acospi(half);
+half2 __ovld __cnfn acospi(half2);
+half3 __ovld __cnfn acospi(half3);
+half4 __ovld __cnfn acospi(half4);
+half8 __ovld __cnfn acospi(half8);
+half16 __ovld __cnfn acospi(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Arc sine function.
+ */
+float __ovld __cnfn asin(float);
+float2 __ovld __cnfn asin(float2);
+float3 __ovld __cnfn asin(float3);
+float4 __ovld __cnfn asin(float4);
+float8 __ovld __cnfn asin(float8);
+float16 __ovld __cnfn asin(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn asin(double);
+double2 __ovld __cnfn asin(double2);
+double3 __ovld __cnfn asin(double3);
+double4 __ovld __cnfn asin(double4);
+double8 __ovld __cnfn asin(double8);
+double16 __ovld __cnfn asin(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn asin(half);
+half2 __ovld __cnfn asin(half2);
+half3 __ovld __cnfn asin(half3);
+half4 __ovld __cnfn asin(half4);
+half8 __ovld __cnfn asin(half8);
+half16 __ovld __cnfn asin(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Inverse hyperbolic sine.
+ */
+float __ovld __cnfn asinh(float);
+float2 __ovld __cnfn asinh(float2);
+float3 __ovld __cnfn asinh(float3);
+float4 __ovld __cnfn asinh(float4);
+float8 __ovld __cnfn asinh(float8);
+float16 __ovld __cnfn asinh(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn asinh(double);
+double2 __ovld __cnfn asinh(double2);
+double3 __ovld __cnfn asinh(double3);
+double4 __ovld __cnfn asinh(double4);
+double8 __ovld __cnfn asinh(double8);
+double16 __ovld __cnfn asinh(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn asinh(half);
+half2 __ovld __cnfn asinh(half2);
+half3 __ovld __cnfn asinh(half3);
+half4 __ovld __cnfn asinh(half4);
+half8 __ovld __cnfn asinh(half8);
+half16 __ovld __cnfn asinh(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute asin (x) / PI.
+ */
+float __ovld __cnfn asinpi(float);
+float2 __ovld __cnfn asinpi(float2);
+float3 __ovld __cnfn asinpi(float3);
+float4 __ovld __cnfn asinpi(float4);
+float8 __ovld __cnfn asinpi(float8);
+float16 __ovld __cnfn asinpi(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn asinpi(double);
+double2 __ovld __cnfn asinpi(double2);
+double3 __ovld __cnfn asinpi(double3);
+double4 __ovld __cnfn asinpi(double4);
+double8 __ovld __cnfn asinpi(double8);
+double16 __ovld __cnfn asinpi(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn asinpi(half);
+half2 __ovld __cnfn asinpi(half2);
+half3 __ovld __cnfn asinpi(half3);
+half4 __ovld __cnfn asinpi(half4);
+half8 __ovld __cnfn asinpi(half8);
+half16 __ovld __cnfn asinpi(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Arc tangent function.
+ */
+float __ovld __cnfn atan(float);
+float2 __ovld __cnfn atan(float2);
+float3 __ovld __cnfn atan(float3);
+float4 __ovld __cnfn atan(float4);
+float8 __ovld __cnfn atan(float8);
+float16 __ovld __cnfn atan(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn atan(double);
+double2 __ovld __cnfn atan(double2);
+double3 __ovld __cnfn atan(double3);
+double4 __ovld __cnfn atan(double4);
+double8 __ovld __cnfn atan(double8);
+double16 __ovld __cnfn atan(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn atan(half);
+half2 __ovld __cnfn atan(half2);
+half3 __ovld __cnfn atan(half3);
+half4 __ovld __cnfn atan(half4);
+half8 __ovld __cnfn atan(half8);
+half16 __ovld __cnfn atan(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Arc tangent of y / x.
+ */
+float __ovld __cnfn atan2(float, float);
+float2 __ovld __cnfn atan2(float2, float2);
+float3 __ovld __cnfn atan2(float3, float3);
+float4 __ovld __cnfn atan2(float4, float4);
+float8 __ovld __cnfn atan2(float8, float8);
+float16 __ovld __cnfn atan2(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn atan2(double, double);
+double2 __ovld __cnfn atan2(double2, double2);
+double3 __ovld __cnfn atan2(double3, double3);
+double4 __ovld __cnfn atan2(double4, double4);
+double8 __ovld __cnfn atan2(double8, double8);
+double16 __ovld __cnfn atan2(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn atan2(half, half);
+half2 __ovld __cnfn atan2(half2, half2);
+half3 __ovld __cnfn atan2(half3, half3);
+half4 __ovld __cnfn atan2(half4, half4);
+half8 __ovld __cnfn atan2(half8, half8);
+half16 __ovld __cnfn atan2(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Hyperbolic arc tangent.
+ */
+float __ovld __cnfn atanh(float);
+float2 __ovld __cnfn atanh(float2);
+float3 __ovld __cnfn atanh(float3);
+float4 __ovld __cnfn atanh(float4);
+float8 __ovld __cnfn atanh(float8);
+float16 __ovld __cnfn atanh(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn atanh(double);
+double2 __ovld __cnfn atanh(double2);
+double3 __ovld __cnfn atanh(double3);
+double4 __ovld __cnfn atanh(double4);
+double8 __ovld __cnfn atanh(double8);
+double16 __ovld __cnfn atanh(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn atanh(half);
+half2 __ovld __cnfn atanh(half2);
+half3 __ovld __cnfn atanh(half3);
+half4 __ovld __cnfn atanh(half4);
+half8 __ovld __cnfn atanh(half8);
+half16 __ovld __cnfn atanh(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute atan (x) / PI.
+ */
+float __ovld __cnfn atanpi(float);
+float2 __ovld __cnfn atanpi(float2);
+float3 __ovld __cnfn atanpi(float3);
+float4 __ovld __cnfn atanpi(float4);
+float8 __ovld __cnfn atanpi(float8);
+float16 __ovld __cnfn atanpi(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn atanpi(double);
+double2 __ovld __cnfn atanpi(double2);
+double3 __ovld __cnfn atanpi(double3);
+double4 __ovld __cnfn atanpi(double4);
+double8 __ovld __cnfn atanpi(double8);
+double16 __ovld __cnfn atanpi(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn atanpi(half);
+half2 __ovld __cnfn atanpi(half2);
+half3 __ovld __cnfn atanpi(half3);
+half4 __ovld __cnfn atanpi(half4);
+half8 __ovld __cnfn atanpi(half8);
+half16 __ovld __cnfn atanpi(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute atan2 (y, x) / PI.
+ */
+float __ovld __cnfn atan2pi(float, float);
+float2 __ovld __cnfn atan2pi(float2, float2);
+float3 __ovld __cnfn atan2pi(float3, float3);
+float4 __ovld __cnfn atan2pi(float4, float4);
+float8 __ovld __cnfn atan2pi(float8, float8);
+float16 __ovld __cnfn atan2pi(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn atan2pi(double, double);
+double2 __ovld __cnfn atan2pi(double2, double2);
+double3 __ovld __cnfn atan2pi(double3, double3);
+double4 __ovld __cnfn atan2pi(double4, double4);
+double8 __ovld __cnfn atan2pi(double8, double8);
+double16 __ovld __cnfn atan2pi(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn atan2pi(half, half);
+half2 __ovld __cnfn atan2pi(half2, half2);
+half3 __ovld __cnfn atan2pi(half3, half3);
+half4 __ovld __cnfn atan2pi(half4, half4);
+half8 __ovld __cnfn atan2pi(half8, half8);
+half16 __ovld __cnfn atan2pi(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute cube-root.
+ */
+float __ovld __cnfn cbrt(float);
+float2 __ovld __cnfn cbrt(float2);
+float3 __ovld __cnfn cbrt(float3);
+float4 __ovld __cnfn cbrt(float4);
+float8 __ovld __cnfn cbrt(float8);
+float16 __ovld __cnfn cbrt(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn cbrt(double);
+double2 __ovld __cnfn cbrt(double2);
+double3 __ovld __cnfn cbrt(double3);
+double4 __ovld __cnfn cbrt(double4);
+double8 __ovld __cnfn cbrt(double8);
+double16 __ovld __cnfn cbrt(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn cbrt(half);
+half2 __ovld __cnfn cbrt(half2);
+half3 __ovld __cnfn cbrt(half3);
+half4 __ovld __cnfn cbrt(half4);
+half8 __ovld __cnfn cbrt(half8);
+half16 __ovld __cnfn cbrt(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Round to integral value using the round to positive
+ * infinity rounding mode.
+ */
+float __ovld __cnfn ceil(float);
+float2 __ovld __cnfn ceil(float2);
+float3 __ovld __cnfn ceil(float3);
+float4 __ovld __cnfn ceil(float4);
+float8 __ovld __cnfn ceil(float8);
+float16 __ovld __cnfn ceil(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn ceil(double);
+double2 __ovld __cnfn ceil(double2);
+double3 __ovld __cnfn ceil(double3);
+double4 __ovld __cnfn ceil(double4);
+double8 __ovld __cnfn ceil(double8);
+double16 __ovld __cnfn ceil(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn ceil(half);
+half2 __ovld __cnfn ceil(half2);
+half3 __ovld __cnfn ceil(half3);
+half4 __ovld __cnfn ceil(half4);
+half8 __ovld __cnfn ceil(half8);
+half16 __ovld __cnfn ceil(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns x with its sign changed to match the sign of y.
+ */
+float __ovld __cnfn copysign(float, float);
+float2 __ovld __cnfn copysign(float2, float2);
+float3 __ovld __cnfn copysign(float3, float3);
+float4 __ovld __cnfn copysign(float4, float4);
+float8 __ovld __cnfn copysign(float8, float8);
+float16 __ovld __cnfn copysign(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn copysign(double, double);
+double2 __ovld __cnfn copysign(double2, double2);
+double3 __ovld __cnfn copysign(double3, double3);
+double4 __ovld __cnfn copysign(double4, double4);
+double8 __ovld __cnfn copysign(double8, double8);
+double16 __ovld __cnfn copysign(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn copysign(half, half);
+half2 __ovld __cnfn copysign(half2, half2);
+half3 __ovld __cnfn copysign(half3, half3);
+half4 __ovld __cnfn copysign(half4, half4);
+half8 __ovld __cnfn copysign(half8, half8);
+half16 __ovld __cnfn copysign(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute cosine.
+ */
+float __ovld __cnfn cos(float);
+float2 __ovld __cnfn cos(float2);
+float3 __ovld __cnfn cos(float3);
+float4 __ovld __cnfn cos(float4);
+float8 __ovld __cnfn cos(float8);
+float16 __ovld __cnfn cos(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn cos(double);
+double2 __ovld __cnfn cos(double2);
+double3 __ovld __cnfn cos(double3);
+double4 __ovld __cnfn cos(double4);
+double8 __ovld __cnfn cos(double8);
+double16 __ovld __cnfn cos(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn cos(half);
+half2 __ovld __cnfn cos(half2);
+half3 __ovld __cnfn cos(half3);
+half4 __ovld __cnfn cos(half4);
+half8 __ovld __cnfn cos(half8);
+half16 __ovld __cnfn cos(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute hyperbolic cosine.
+ */
+float __ovld __cnfn cosh(float);
+float2 __ovld __cnfn cosh(float2);
+float3 __ovld __cnfn cosh(float3);
+float4 __ovld __cnfn cosh(float4);
+float8 __ovld __cnfn cosh(float8);
+float16 __ovld __cnfn cosh(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn cosh(double);
+double2 __ovld __cnfn cosh(double2);
+double3 __ovld __cnfn cosh(double3);
+double4 __ovld __cnfn cosh(double4);
+double8 __ovld __cnfn cosh(double8);
+double16 __ovld __cnfn cosh(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn cosh(half);
+half2 __ovld __cnfn cosh(half2);
+half3 __ovld __cnfn cosh(half3);
+half4 __ovld __cnfn cosh(half4);
+half8 __ovld __cnfn cosh(half8);
+half16 __ovld __cnfn cosh(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute cos (PI * x).
+ */
+float __ovld __cnfn cospi(float);
+float2 __ovld __cnfn cospi(float2);
+float3 __ovld __cnfn cospi(float3);
+float4 __ovld __cnfn cospi(float4);
+float8 __ovld __cnfn cospi(float8);
+float16 __ovld __cnfn cospi(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn cospi(double);
+double2 __ovld __cnfn cospi(double2);
+double3 __ovld __cnfn cospi(double3);
+double4 __ovld __cnfn cospi(double4);
+double8 __ovld __cnfn cospi(double8);
+double16 __ovld __cnfn cospi(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn cospi(half);
+half2 __ovld __cnfn cospi(half2);
+half3 __ovld __cnfn cospi(half3);
+half4 __ovld __cnfn cospi(half4);
+half8 __ovld __cnfn cospi(half8);
+half16 __ovld __cnfn cospi(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Complementary error function.
+ */
+float __ovld __cnfn erfc(float);
+float2 __ovld __cnfn erfc(float2);
+float3 __ovld __cnfn erfc(float3);
+float4 __ovld __cnfn erfc(float4);
+float8 __ovld __cnfn erfc(float8);
+float16 __ovld __cnfn erfc(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn erfc(double);
+double2 __ovld __cnfn erfc(double2);
+double3 __ovld __cnfn erfc(double3);
+double4 __ovld __cnfn erfc(double4);
+double8 __ovld __cnfn erfc(double8);
+double16 __ovld __cnfn erfc(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn erfc(half);
+half2 __ovld __cnfn erfc(half2);
+half3 __ovld __cnfn erfc(half3);
+half4 __ovld __cnfn erfc(half4);
+half8 __ovld __cnfn erfc(half8);
+half16 __ovld __cnfn erfc(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Error function encountered in integrating the
+ * normal distribution.
+ */
+float __ovld __cnfn erf(float);
+float2 __ovld __cnfn erf(float2);
+float3 __ovld __cnfn erf(float3);
+float4 __ovld __cnfn erf(float4);
+float8 __ovld __cnfn erf(float8);
+float16 __ovld __cnfn erf(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn erf(double);
+double2 __ovld __cnfn erf(double2);
+double3 __ovld __cnfn erf(double3);
+double4 __ovld __cnfn erf(double4);
+double8 __ovld __cnfn erf(double8);
+double16 __ovld __cnfn erf(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn erf(half);
+half2 __ovld __cnfn erf(half2);
+half3 __ovld __cnfn erf(half3);
+half4 __ovld __cnfn erf(half4);
+half8 __ovld __cnfn erf(half8);
+half16 __ovld __cnfn erf(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute the base e exponential function of x.
+ */
+float __ovld __cnfn exp(float);
+float2 __ovld __cnfn exp(float2);
+float3 __ovld __cnfn exp(float3);
+float4 __ovld __cnfn exp(float4);
+float8 __ovld __cnfn exp(float8);
+float16 __ovld __cnfn exp(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn exp(double);
+double2 __ovld __cnfn exp(double2);
+double3 __ovld __cnfn exp(double3);
+double4 __ovld __cnfn exp(double4);
+double8 __ovld __cnfn exp(double8);
+double16 __ovld __cnfn exp(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn exp(half);
+half2 __ovld __cnfn exp(half2);
+half3 __ovld __cnfn exp(half3);
+half4 __ovld __cnfn exp(half4);
+half8 __ovld __cnfn exp(half8);
+half16 __ovld __cnfn exp(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Exponential base 2 function.
+ */
+float __ovld __cnfn exp2(float);
+float2 __ovld __cnfn exp2(float2);
+float3 __ovld __cnfn exp2(float3);
+float4 __ovld __cnfn exp2(float4);
+float8 __ovld __cnfn exp2(float8);
+float16 __ovld __cnfn exp2(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn exp2(double);
+double2 __ovld __cnfn exp2(double2);
+double3 __ovld __cnfn exp2(double3);
+double4 __ovld __cnfn exp2(double4);
+double8 __ovld __cnfn exp2(double8);
+double16 __ovld __cnfn exp2(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn exp2(half);
+half2 __ovld __cnfn exp2(half2);
+half3 __ovld __cnfn exp2(half3);
+half4 __ovld __cnfn exp2(half4);
+half8 __ovld __cnfn exp2(half8);
+half16 __ovld __cnfn exp2(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Exponential base 10 function.
+ */
+float __ovld __cnfn exp10(float);
+float2 __ovld __cnfn exp10(float2);
+float3 __ovld __cnfn exp10(float3);
+float4 __ovld __cnfn exp10(float4);
+float8 __ovld __cnfn exp10(float8);
+float16 __ovld __cnfn exp10(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn exp10(double);
+double2 __ovld __cnfn exp10(double2);
+double3 __ovld __cnfn exp10(double3);
+double4 __ovld __cnfn exp10(double4);
+double8 __ovld __cnfn exp10(double8);
+double16 __ovld __cnfn exp10(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn exp10(half);
+half2 __ovld __cnfn exp10(half2);
+half3 __ovld __cnfn exp10(half3);
+half4 __ovld __cnfn exp10(half4);
+half8 __ovld __cnfn exp10(half8);
+half16 __ovld __cnfn exp10(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute e^x- 1.0.
+ */
+float __ovld __cnfn expm1(float);
+float2 __ovld __cnfn expm1(float2);
+float3 __ovld __cnfn expm1(float3);
+float4 __ovld __cnfn expm1(float4);
+float8 __ovld __cnfn expm1(float8);
+float16 __ovld __cnfn expm1(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn expm1(double);
+double2 __ovld __cnfn expm1(double2);
+double3 __ovld __cnfn expm1(double3);
+double4 __ovld __cnfn expm1(double4);
+double8 __ovld __cnfn expm1(double8);
+double16 __ovld __cnfn expm1(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn expm1(half);
+half2 __ovld __cnfn expm1(half2);
+half3 __ovld __cnfn expm1(half3);
+half4 __ovld __cnfn expm1(half4);
+half8 __ovld __cnfn expm1(half8);
+half16 __ovld __cnfn expm1(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute absolute value of a floating-point number.
+ */
+float __ovld __cnfn fabs(float);
+float2 __ovld __cnfn fabs(float2);
+float3 __ovld __cnfn fabs(float3);
+float4 __ovld __cnfn fabs(float4);
+float8 __ovld __cnfn fabs(float8);
+float16 __ovld __cnfn fabs(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn fabs(double);
+double2 __ovld __cnfn fabs(double2);
+double3 __ovld __cnfn fabs(double3);
+double4 __ovld __cnfn fabs(double4);
+double8 __ovld __cnfn fabs(double8);
+double16 __ovld __cnfn fabs(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn fabs(half);
+half2 __ovld __cnfn fabs(half2);
+half3 __ovld __cnfn fabs(half3);
+half4 __ovld __cnfn fabs(half4);
+half8 __ovld __cnfn fabs(half8);
+half16 __ovld __cnfn fabs(half16);
+#endif //cl_khr_fp16
+
+/**
+ * x - y if x > y, +0 if x is less than or equal to y.
+ */
+float __ovld __cnfn fdim(float, float);
+float2 __ovld __cnfn fdim(float2, float2);
+float3 __ovld __cnfn fdim(float3, float3);
+float4 __ovld __cnfn fdim(float4, float4);
+float8 __ovld __cnfn fdim(float8, float8);
+float16 __ovld __cnfn fdim(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn fdim(double, double);
+double2 __ovld __cnfn fdim(double2, double2);
+double3 __ovld __cnfn fdim(double3, double3);
+double4 __ovld __cnfn fdim(double4, double4);
+double8 __ovld __cnfn fdim(double8, double8);
+double16 __ovld __cnfn fdim(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn fdim(half, half);
+half2 __ovld __cnfn fdim(half2, half2);
+half3 __ovld __cnfn fdim(half3, half3);
+half4 __ovld __cnfn fdim(half4, half4);
+half8 __ovld __cnfn fdim(half8, half8);
+half16 __ovld __cnfn fdim(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Round to integral value using the round to -ve
+ * infinity rounding mode.
+ */
+float __ovld __cnfn floor(float);
+float2 __ovld __cnfn floor(float2);
+float3 __ovld __cnfn floor(float3);
+float4 __ovld __cnfn floor(float4);
+float8 __ovld __cnfn floor(float8);
+float16 __ovld __cnfn floor(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn floor(double);
+double2 __ovld __cnfn floor(double2);
+double3 __ovld __cnfn floor(double3);
+double4 __ovld __cnfn floor(double4);
+double8 __ovld __cnfn floor(double8);
+double16 __ovld __cnfn floor(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn floor(half);
+half2 __ovld __cnfn floor(half2);
+half3 __ovld __cnfn floor(half3);
+half4 __ovld __cnfn floor(half4);
+half8 __ovld __cnfn floor(half8);
+half16 __ovld __cnfn floor(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the correctly rounded floating-point
+ * representation of the sum of c with the infinitely
+ * precise product of a and b. Rounding of
+ * intermediate products shall not occur. Edge case
+ * behavior is per the IEEE 754-2008 standard.
+ */
+float __ovld __cnfn fma(float, float, float);
+float2 __ovld __cnfn fma(float2, float2, float2);
+float3 __ovld __cnfn fma(float3, float3, float3);
+float4 __ovld __cnfn fma(float4, float4, float4);
+float8 __ovld __cnfn fma(float8, float8, float8);
+float16 __ovld __cnfn fma(float16, float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn fma(double, double, double);
+double2 __ovld __cnfn fma(double2, double2, double2);
+double3 __ovld __cnfn fma(double3, double3, double3);
+double4 __ovld __cnfn fma(double4, double4, double4);
+double8 __ovld __cnfn fma(double8, double8, double8);
+double16 __ovld __cnfn fma(double16, double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn fma(half, half, half);
+half2 __ovld __cnfn fma(half2, half2, half2);
+half3 __ovld __cnfn fma(half3, half3, half3);
+half4 __ovld __cnfn fma(half4, half4, half4);
+half8 __ovld __cnfn fma(half8, half8, half8);
+half16 __ovld __cnfn fma(half16, half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns y if x < y, otherwise it returns x. If one
+ * argument is a NaN, fmax() returns the other
+ * argument. If both arguments are NaNs, fmax()
+ * returns a NaN.
+ */
+float __ovld __cnfn fmax(float, float);
+float2 __ovld __cnfn fmax(float2, float2);
+float3 __ovld __cnfn fmax(float3, float3);
+float4 __ovld __cnfn fmax(float4, float4);
+float8 __ovld __cnfn fmax(float8, float8);
+float16 __ovld __cnfn fmax(float16, float16);
+float2 __ovld __cnfn fmax(float2, float);
+float3 __ovld __cnfn fmax(float3, float);
+float4 __ovld __cnfn fmax(float4, float);
+float8 __ovld __cnfn fmax(float8, float);
+float16 __ovld __cnfn fmax(float16, float);
+#ifdef cl_khr_fp64
+double __ovld __cnfn fmax(double, double);
+double2 __ovld __cnfn fmax(double2, double2);
+double3 __ovld __cnfn fmax(double3, double3);
+double4 __ovld __cnfn fmax(double4, double4);
+double8 __ovld __cnfn fmax(double8, double8);
+double16 __ovld __cnfn fmax(double16, double16);
+double2 __ovld __cnfn fmax(double2, double);
+double3 __ovld __cnfn fmax(double3, double);
+double4 __ovld __cnfn fmax(double4, double);
+double8 __ovld __cnfn fmax(double8, double);
+double16 __ovld __cnfn fmax(double16, double);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn fmax(half, half);
+half2 __ovld __cnfn fmax(half2, half2);
+half3 __ovld __cnfn fmax(half3, half3);
+half4 __ovld __cnfn fmax(half4, half4);
+half8 __ovld __cnfn fmax(half8, half8);
+half16 __ovld __cnfn fmax(half16, half16);
+half2 __ovld __cnfn fmax(half2, half);
+half3 __ovld __cnfn fmax(half3, half);
+half4 __ovld __cnfn fmax(half4, half);
+half8 __ovld __cnfn fmax(half8, half);
+half16 __ovld __cnfn fmax(half16, half);
+#endif //cl_khr_fp16
+
+/**
+ * Returns y if y < x, otherwise it returns x. If one
+ * argument is a NaN, fmin() returns the other
+ * argument. If both arguments are NaNs, fmin()
+ * returns a NaN.
+ */
+float __ovld __cnfn fmin(float, float);
+float2 __ovld __cnfn fmin(float2, float2);
+float3 __ovld __cnfn fmin(float3, float3);
+float4 __ovld __cnfn fmin(float4, float4);
+float8 __ovld __cnfn fmin(float8, float8);
+float16 __ovld __cnfn fmin(float16, float16);
+float2 __ovld __cnfn fmin(float2, float);
+float3 __ovld __cnfn fmin(float3, float);
+float4 __ovld __cnfn fmin(float4, float);
+float8 __ovld __cnfn fmin(float8, float);
+float16 __ovld __cnfn fmin(float16, float);
+#ifdef cl_khr_fp64
+double __ovld __cnfn fmin(double, double);
+double2 __ovld __cnfn fmin(double2, double2);
+double3 __ovld __cnfn fmin(double3, double3);
+double4 __ovld __cnfn fmin(double4, double4);
+double8 __ovld __cnfn fmin(double8, double8);
+double16 __ovld __cnfn fmin(double16, double16);
+double2 __ovld __cnfn fmin(double2, double);
+double3 __ovld __cnfn fmin(double3, double);
+double4 __ovld __cnfn fmin(double4, double);
+double8 __ovld __cnfn fmin(double8, double);
+double16 __ovld __cnfn fmin(double16, double);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn fmin(half, half);
+half2 __ovld __cnfn fmin(half2, half2);
+half3 __ovld __cnfn fmin(half3, half3);
+half4 __ovld __cnfn fmin(half4, half4);
+half8 __ovld __cnfn fmin(half8, half8);
+half16 __ovld __cnfn fmin(half16, half16);
+half2 __ovld __cnfn fmin(half2, half);
+half3 __ovld __cnfn fmin(half3, half);
+half4 __ovld __cnfn fmin(half4, half);
+half8 __ovld __cnfn fmin(half8, half);
+half16 __ovld __cnfn fmin(half16, half);
+#endif //cl_khr_fp16
+
+/**
+ * Modulus. Returns x - y * trunc (x/y).
+ */
+float __ovld __cnfn fmod(float, float);
+float2 __ovld __cnfn fmod(float2, float2);
+float3 __ovld __cnfn fmod(float3, float3);
+float4 __ovld __cnfn fmod(float4, float4);
+float8 __ovld __cnfn fmod(float8, float8);
+float16 __ovld __cnfn fmod(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn fmod(double, double);
+double2 __ovld __cnfn fmod(double2, double2);
+double3 __ovld __cnfn fmod(double3, double3);
+double4 __ovld __cnfn fmod(double4, double4);
+double8 __ovld __cnfn fmod(double8, double8);
+double16 __ovld __cnfn fmod(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn fmod(half, half);
+half2 __ovld __cnfn fmod(half2, half2);
+half3 __ovld __cnfn fmod(half3, half3);
+half4 __ovld __cnfn fmod(half4, half4);
+half8 __ovld __cnfn fmod(half8, half8);
+half16 __ovld __cnfn fmod(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns fmin(x - floor (x), 0x1.fffffep-1f ).
+ * floor(x) is returned in iptr.
+ */
+#if defined(__opencl_c_generic_address_space)
+float __ovld fract(float, float *);
+float2 __ovld fract(float2, float2 *);
+float3 __ovld fract(float3, float3 *);
+float4 __ovld fract(float4, float4 *);
+float8 __ovld fract(float8, float8 *);
+float16 __ovld fract(float16, float16 *);
+#ifdef cl_khr_fp64
+double __ovld fract(double, double *);
+double2 __ovld fract(double2, double2 *);
+double3 __ovld fract(double3, double3 *);
+double4 __ovld fract(double4, double4 *);
+double8 __ovld fract(double8, double8 *);
+double16 __ovld fract(double16, double16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld fract(half, half *);
+half2 __ovld fract(half2, half2 *);
+half3 __ovld fract(half3, half3 *);
+half4 __ovld fract(half4, half4 *);
+half8 __ovld fract(half8, half8 *);
+half16 __ovld fract(half16, half16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld fract(float, __global float *);
+float2 __ovld fract(float2, __global float2 *);
+float3 __ovld fract(float3, __global float3 *);
+float4 __ovld fract(float4, __global float4 *);
+float8 __ovld fract(float8, __global float8 *);
+float16 __ovld fract(float16, __global float16 *);
+float __ovld fract(float, __local float *);
+float2 __ovld fract(float2, __local float2 *);
+float3 __ovld fract(float3, __local float3 *);
+float4 __ovld fract(float4, __local float4 *);
+float8 __ovld fract(float8, __local float8 *);
+float16 __ovld fract(float16, __local float16 *);
+float __ovld fract(float, __private float *);
+float2 __ovld fract(float2, __private float2 *);
+float3 __ovld fract(float3, __private float3 *);
+float4 __ovld fract(float4, __private float4 *);
+float8 __ovld fract(float8, __private float8 *);
+float16 __ovld fract(float16, __private float16 *);
+#ifdef cl_khr_fp64
+double __ovld fract(double, __global double *);
+double2 __ovld fract(double2, __global double2 *);
+double3 __ovld fract(double3, __global double3 *);
+double4 __ovld fract(double4, __global double4 *);
+double8 __ovld fract(double8, __global double8 *);
+double16 __ovld fract(double16, __global double16 *);
+double __ovld fract(double, __local double *);
+double2 __ovld fract(double2, __local double2 *);
+double3 __ovld fract(double3, __local double3 *);
+double4 __ovld fract(double4, __local double4 *);
+double8 __ovld fract(double8, __local double8 *);
+double16 __ovld fract(double16, __local double16 *);
+double __ovld fract(double, __private double *);
+double2 __ovld fract(double2, __private double2 *);
+double3 __ovld fract(double3, __private double3 *);
+double4 __ovld fract(double4, __private double4 *);
+double8 __ovld fract(double8, __private double8 *);
+double16 __ovld fract(double16, __private double16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld fract(half, __global half *);
+half2 __ovld fract(half2, __global half2 *);
+half3 __ovld fract(half3, __global half3 *);
+half4 __ovld fract(half4, __global half4 *);
+half8 __ovld fract(half8, __global half8 *);
+half16 __ovld fract(half16, __global half16 *);
+half __ovld fract(half, __local half *);
+half2 __ovld fract(half2, __local half2 *);
+half3 __ovld fract(half3, __local half3 *);
+half4 __ovld fract(half4, __local half4 *);
+half8 __ovld fract(half8, __local half8 *);
+half16 __ovld fract(half16, __local half16 *);
+half __ovld fract(half, __private half *);
+half2 __ovld fract(half2, __private half2 *);
+half3 __ovld fract(half3, __private half3 *);
+half4 __ovld fract(half4, __private half4 *);
+half8 __ovld fract(half8, __private half8 *);
+half16 __ovld fract(half16, __private half16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Extract mantissa and exponent from x. For each
+ * component the mantissa returned is a float with
+ * magnitude in the interval [1/2, 1) or 0. Each
+ * component of x equals mantissa returned * 2^exp.
+ */
+#if defined(__opencl_c_generic_address_space)
+float __ovld frexp(float, int *);
+float2 __ovld frexp(float2, int2 *);
+float3 __ovld frexp(float3, int3 *);
+float4 __ovld frexp(float4, int4 *);
+float8 __ovld frexp(float8, int8 *);
+float16 __ovld frexp(float16, int16 *);
+#ifdef cl_khr_fp64
+double __ovld frexp(double, int *);
+double2 __ovld frexp(double2, int2 *);
+double3 __ovld frexp(double3, int3 *);
+double4 __ovld frexp(double4, int4 *);
+double8 __ovld frexp(double8, int8 *);
+double16 __ovld frexp(double16, int16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld frexp(half, int *);
+half2 __ovld frexp(half2, int2 *);
+half3 __ovld frexp(half3, int3 *);
+half4 __ovld frexp(half4, int4 *);
+half8 __ovld frexp(half8, int8 *);
+half16 __ovld frexp(half16, int16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld frexp(float, __global int *);
+float2 __ovld frexp(float2, __global int2 *);
+float3 __ovld frexp(float3, __global int3 *);
+float4 __ovld frexp(float4, __global int4 *);
+float8 __ovld frexp(float8, __global int8 *);
+float16 __ovld frexp(float16, __global int16 *);
+float __ovld frexp(float, __local int *);
+float2 __ovld frexp(float2, __local int2 *);
+float3 __ovld frexp(float3, __local int3 *);
+float4 __ovld frexp(float4, __local int4 *);
+float8 __ovld frexp(float8, __local int8 *);
+float16 __ovld frexp(float16, __local int16 *);
+float __ovld frexp(float, __private int *);
+float2 __ovld frexp(float2, __private int2 *);
+float3 __ovld frexp(float3, __private int3 *);
+float4 __ovld frexp(float4, __private int4 *);
+float8 __ovld frexp(float8, __private int8 *);
+float16 __ovld frexp(float16, __private int16 *);
+#ifdef cl_khr_fp64
+double __ovld frexp(double, __global int *);
+double2 __ovld frexp(double2, __global int2 *);
+double3 __ovld frexp(double3, __global int3 *);
+double4 __ovld frexp(double4, __global int4 *);
+double8 __ovld frexp(double8, __global int8 *);
+double16 __ovld frexp(double16, __global int16 *);
+double __ovld frexp(double, __local int *);
+double2 __ovld frexp(double2, __local int2 *);
+double3 __ovld frexp(double3, __local int3 *);
+double4 __ovld frexp(double4, __local int4 *);
+double8 __ovld frexp(double8, __local int8 *);
+double16 __ovld frexp(double16, __local int16 *);
+double __ovld frexp(double, __private int *);
+double2 __ovld frexp(double2, __private int2 *);
+double3 __ovld frexp(double3, __private int3 *);
+double4 __ovld frexp(double4, __private int4 *);
+double8 __ovld frexp(double8, __private int8 *);
+double16 __ovld frexp(double16, __private int16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld frexp(half, __global int *);
+half2 __ovld frexp(half2, __global int2 *);
+half3 __ovld frexp(half3, __global int3 *);
+half4 __ovld frexp(half4, __global int4 *);
+half8 __ovld frexp(half8, __global int8 *);
+half16 __ovld frexp(half16, __global int16 *);
+half __ovld frexp(half, __local int *);
+half2 __ovld frexp(half2, __local int2 *);
+half3 __ovld frexp(half3, __local int3 *);
+half4 __ovld frexp(half4, __local int4 *);
+half8 __ovld frexp(half8, __local int8 *);
+half16 __ovld frexp(half16, __local int16 *);
+half __ovld frexp(half, __private int *);
+half2 __ovld frexp(half2, __private int2 *);
+half3 __ovld frexp(half3, __private int3 *);
+half4 __ovld frexp(half4, __private int4 *);
+half8 __ovld frexp(half8, __private int8 *);
+half16 __ovld frexp(half16, __private int16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Compute the value of the square root of x^2 + y^2
+ * without undue overflow or underflow.
+ */
+float __ovld __cnfn hypot(float, float);
+float2 __ovld __cnfn hypot(float2, float2);
+float3 __ovld __cnfn hypot(float3, float3);
+float4 __ovld __cnfn hypot(float4, float4);
+float8 __ovld __cnfn hypot(float8, float8);
+float16 __ovld __cnfn hypot(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn hypot(double, double);
+double2 __ovld __cnfn hypot(double2, double2);
+double3 __ovld __cnfn hypot(double3, double3);
+double4 __ovld __cnfn hypot(double4, double4);
+double8 __ovld __cnfn hypot(double8, double8);
+double16 __ovld __cnfn hypot(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn hypot(half, half);
+half2 __ovld __cnfn hypot(half2, half2);
+half3 __ovld __cnfn hypot(half3, half3);
+half4 __ovld __cnfn hypot(half4, half4);
+half8 __ovld __cnfn hypot(half8, half8);
+half16 __ovld __cnfn hypot(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Return the exponent as an integer value.
+ */
+int __ovld __cnfn ilogb(float);
+int2 __ovld __cnfn ilogb(float2);
+int3 __ovld __cnfn ilogb(float3);
+int4 __ovld __cnfn ilogb(float4);
+int8 __ovld __cnfn ilogb(float8);
+int16 __ovld __cnfn ilogb(float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn ilogb(double);
+int2 __ovld __cnfn ilogb(double2);
+int3 __ovld __cnfn ilogb(double3);
+int4 __ovld __cnfn ilogb(double4);
+int8 __ovld __cnfn ilogb(double8);
+int16 __ovld __cnfn ilogb(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn ilogb(half);
+int2 __ovld __cnfn ilogb(half2);
+int3 __ovld __cnfn ilogb(half3);
+int4 __ovld __cnfn ilogb(half4);
+int8 __ovld __cnfn ilogb(half8);
+int16 __ovld __cnfn ilogb(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Multiply x by 2 to the power n.
+ */
+float __ovld __cnfn ldexp(float, int);
+float2 __ovld __cnfn ldexp(float2, int2);
+float3 __ovld __cnfn ldexp(float3, int3);
+float4 __ovld __cnfn ldexp(float4, int4);
+float8 __ovld __cnfn ldexp(float8, int8);
+float16 __ovld __cnfn ldexp(float16, int16);
+float2 __ovld __cnfn ldexp(float2, int);
+float3 __ovld __cnfn ldexp(float3, int);
+float4 __ovld __cnfn ldexp(float4, int);
+float8 __ovld __cnfn ldexp(float8, int);
+float16 __ovld __cnfn ldexp(float16, int);
+#ifdef cl_khr_fp64
+double __ovld __cnfn ldexp(double, int);
+double2 __ovld __cnfn ldexp(double2, int2);
+double3 __ovld __cnfn ldexp(double3, int3);
+double4 __ovld __cnfn ldexp(double4, int4);
+double8 __ovld __cnfn ldexp(double8, int8);
+double16 __ovld __cnfn ldexp(double16, int16);
+double2 __ovld __cnfn ldexp(double2, int);
+double3 __ovld __cnfn ldexp(double3, int);
+double4 __ovld __cnfn ldexp(double4, int);
+double8 __ovld __cnfn ldexp(double8, int);
+double16 __ovld __cnfn ldexp(double16, int);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn ldexp(half, int);
+half2 __ovld __cnfn ldexp(half2, int2);
+half3 __ovld __cnfn ldexp(half3, int3);
+half4 __ovld __cnfn ldexp(half4, int4);
+half8 __ovld __cnfn ldexp(half8, int8);
+half16 __ovld __cnfn ldexp(half16, int16);
+half2 __ovld __cnfn ldexp(half2, int);
+half3 __ovld __cnfn ldexp(half3, int);
+half4 __ovld __cnfn ldexp(half4, int);
+half8 __ovld __cnfn ldexp(half8, int);
+half16 __ovld __cnfn ldexp(half16, int);
+#endif //cl_khr_fp16
+
+/**
+ * Log gamma function. Returns the natural
+ * logarithm of the absolute value of the gamma
+ * function. The sign of the gamma function is
+ * returned in the signp argument of lgamma_r.
+ */
+float __ovld __cnfn lgamma(float);
+float2 __ovld __cnfn lgamma(float2);
+float3 __ovld __cnfn lgamma(float3);
+float4 __ovld __cnfn lgamma(float4);
+float8 __ovld __cnfn lgamma(float8);
+float16 __ovld __cnfn lgamma(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn lgamma(double);
+double2 __ovld __cnfn lgamma(double2);
+double3 __ovld __cnfn lgamma(double3);
+double4 __ovld __cnfn lgamma(double4);
+double8 __ovld __cnfn lgamma(double8);
+double16 __ovld __cnfn lgamma(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn lgamma(half);
+half2 __ovld __cnfn lgamma(half2);
+half3 __ovld __cnfn lgamma(half3);
+half4 __ovld __cnfn lgamma(half4);
+half8 __ovld __cnfn lgamma(half8);
+half16 __ovld __cnfn lgamma(half16);
+#endif //cl_khr_fp16
+
+#if defined(__opencl_c_generic_address_space)
+float __ovld lgamma_r(float, int *);
+float2 __ovld lgamma_r(float2, int2 *);
+float3 __ovld lgamma_r(float3, int3 *);
+float4 __ovld lgamma_r(float4, int4 *);
+float8 __ovld lgamma_r(float8, int8 *);
+float16 __ovld lgamma_r(float16, int16 *);
+#ifdef cl_khr_fp64
+double __ovld lgamma_r(double, int *);
+double2 __ovld lgamma_r(double2, int2 *);
+double3 __ovld lgamma_r(double3, int3 *);
+double4 __ovld lgamma_r(double4, int4 *);
+double8 __ovld lgamma_r(double8, int8 *);
+double16 __ovld lgamma_r(double16, int16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld lgamma_r(half, int *);
+half2 __ovld lgamma_r(half2, int2 *);
+half3 __ovld lgamma_r(half3, int3 *);
+half4 __ovld lgamma_r(half4, int4 *);
+half8 __ovld lgamma_r(half8, int8 *);
+half16 __ovld lgamma_r(half16, int16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld lgamma_r(float, __global int *);
+float2 __ovld lgamma_r(float2, __global int2 *);
+float3 __ovld lgamma_r(float3, __global int3 *);
+float4 __ovld lgamma_r(float4, __global int4 *);
+float8 __ovld lgamma_r(float8, __global int8 *);
+float16 __ovld lgamma_r(float16, __global int16 *);
+float __ovld lgamma_r(float, __local int *);
+float2 __ovld lgamma_r(float2, __local int2 *);
+float3 __ovld lgamma_r(float3, __local int3 *);
+float4 __ovld lgamma_r(float4, __local int4 *);
+float8 __ovld lgamma_r(float8, __local int8 *);
+float16 __ovld lgamma_r(float16, __local int16 *);
+float __ovld lgamma_r(float, __private int *);
+float2 __ovld lgamma_r(float2, __private int2 *);
+float3 __ovld lgamma_r(float3, __private int3 *);
+float4 __ovld lgamma_r(float4, __private int4 *);
+float8 __ovld lgamma_r(float8, __private int8 *);
+float16 __ovld lgamma_r(float16, __private int16 *);
+#ifdef cl_khr_fp64
+double __ovld lgamma_r(double, __global int *);
+double2 __ovld lgamma_r(double2, __global int2 *);
+double3 __ovld lgamma_r(double3, __global int3 *);
+double4 __ovld lgamma_r(double4, __global int4 *);
+double8 __ovld lgamma_r(double8, __global int8 *);
+double16 __ovld lgamma_r(double16, __global int16 *);
+double __ovld lgamma_r(double, __local int *);
+double2 __ovld lgamma_r(double2, __local int2 *);
+double3 __ovld lgamma_r(double3, __local int3 *);
+double4 __ovld lgamma_r(double4, __local int4 *);
+double8 __ovld lgamma_r(double8, __local int8 *);
+double16 __ovld lgamma_r(double16, __local int16 *);
+double __ovld lgamma_r(double, __private int *);
+double2 __ovld lgamma_r(double2, __private int2 *);
+double3 __ovld lgamma_r(double3, __private int3 *);
+double4 __ovld lgamma_r(double4, __private int4 *);
+double8 __ovld lgamma_r(double8, __private int8 *);
+double16 __ovld lgamma_r(double16, __private int16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld lgamma_r(half, __global int *);
+half2 __ovld lgamma_r(half2, __global int2 *);
+half3 __ovld lgamma_r(half3, __global int3 *);
+half4 __ovld lgamma_r(half4, __global int4 *);
+half8 __ovld lgamma_r(half8, __global int8 *);
+half16 __ovld lgamma_r(half16, __global int16 *);
+half __ovld lgamma_r(half, __local int *);
+half2 __ovld lgamma_r(half2, __local int2 *);
+half3 __ovld lgamma_r(half3, __local int3 *);
+half4 __ovld lgamma_r(half4, __local int4 *);
+half8 __ovld lgamma_r(half8, __local int8 *);
+half16 __ovld lgamma_r(half16, __local int16 *);
+half __ovld lgamma_r(half, __private int *);
+half2 __ovld lgamma_r(half2, __private int2 *);
+half3 __ovld lgamma_r(half3, __private int3 *);
+half4 __ovld lgamma_r(half4, __private int4 *);
+half8 __ovld lgamma_r(half8, __private int8 *);
+half16 __ovld lgamma_r(half16, __private int16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Compute natural logarithm.
+ */
+float __ovld __cnfn log(float);
+float2 __ovld __cnfn log(float2);
+float3 __ovld __cnfn log(float3);
+float4 __ovld __cnfn log(float4);
+float8 __ovld __cnfn log(float8);
+float16 __ovld __cnfn log(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn log(double);
+double2 __ovld __cnfn log(double2);
+double3 __ovld __cnfn log(double3);
+double4 __ovld __cnfn log(double4);
+double8 __ovld __cnfn log(double8);
+double16 __ovld __cnfn log(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn log(half);
+half2 __ovld __cnfn log(half2);
+half3 __ovld __cnfn log(half3);
+half4 __ovld __cnfn log(half4);
+half8 __ovld __cnfn log(half8);
+half16 __ovld __cnfn log(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute a base 2 logarithm.
+ */
+float __ovld __cnfn log2(float);
+float2 __ovld __cnfn log2(float2);
+float3 __ovld __cnfn log2(float3);
+float4 __ovld __cnfn log2(float4);
+float8 __ovld __cnfn log2(float8);
+float16 __ovld __cnfn log2(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn log2(double);
+double2 __ovld __cnfn log2(double2);
+double3 __ovld __cnfn log2(double3);
+double4 __ovld __cnfn log2(double4);
+double8 __ovld __cnfn log2(double8);
+double16 __ovld __cnfn log2(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn log2(half);
+half2 __ovld __cnfn log2(half2);
+half3 __ovld __cnfn log2(half3);
+half4 __ovld __cnfn log2(half4);
+half8 __ovld __cnfn log2(half8);
+half16 __ovld __cnfn log2(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute a base 10 logarithm.
+ */
+float __ovld __cnfn log10(float);
+float2 __ovld __cnfn log10(float2);
+float3 __ovld __cnfn log10(float3);
+float4 __ovld __cnfn log10(float4);
+float8 __ovld __cnfn log10(float8);
+float16 __ovld __cnfn log10(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn log10(double);
+double2 __ovld __cnfn log10(double2);
+double3 __ovld __cnfn log10(double3);
+double4 __ovld __cnfn log10(double4);
+double8 __ovld __cnfn log10(double8);
+double16 __ovld __cnfn log10(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn log10(half);
+half2 __ovld __cnfn log10(half2);
+half3 __ovld __cnfn log10(half3);
+half4 __ovld __cnfn log10(half4);
+half8 __ovld __cnfn log10(half8);
+half16 __ovld __cnfn log10(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute a base e logarithm of (1.0 + x).
+ */
+float __ovld __cnfn log1p(float);
+float2 __ovld __cnfn log1p(float2);
+float3 __ovld __cnfn log1p(float3);
+float4 __ovld __cnfn log1p(float4);
+float8 __ovld __cnfn log1p(float8);
+float16 __ovld __cnfn log1p(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn log1p(double);
+double2 __ovld __cnfn log1p(double2);
+double3 __ovld __cnfn log1p(double3);
+double4 __ovld __cnfn log1p(double4);
+double8 __ovld __cnfn log1p(double8);
+double16 __ovld __cnfn log1p(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn log1p(half);
+half2 __ovld __cnfn log1p(half2);
+half3 __ovld __cnfn log1p(half3);
+half4 __ovld __cnfn log1p(half4);
+half8 __ovld __cnfn log1p(half8);
+half16 __ovld __cnfn log1p(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute the exponent of x, which is the integral
+ * part of logr | x |.
+ */
+float __ovld __cnfn logb(float);
+float2 __ovld __cnfn logb(float2);
+float3 __ovld __cnfn logb(float3);
+float4 __ovld __cnfn logb(float4);
+float8 __ovld __cnfn logb(float8);
+float16 __ovld __cnfn logb(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn logb(double);
+double2 __ovld __cnfn logb(double2);
+double3 __ovld __cnfn logb(double3);
+double4 __ovld __cnfn logb(double4);
+double8 __ovld __cnfn logb(double8);
+double16 __ovld __cnfn logb(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn logb(half);
+half2 __ovld __cnfn logb(half2);
+half3 __ovld __cnfn logb(half3);
+half4 __ovld __cnfn logb(half4);
+half8 __ovld __cnfn logb(half8);
+half16 __ovld __cnfn logb(half16);
+#endif //cl_khr_fp16
+
+/**
+ * mad approximates a * b + c. Whether or how the
+ * product of a * b is rounded and how supernormal or
+ * subnormal intermediate products are handled is not
+ * defined. mad is intended to be used where speed is
+ * preferred over accuracy.
+ */
+float __ovld __cnfn mad(float, float, float);
+float2 __ovld __cnfn mad(float2, float2, float2);
+float3 __ovld __cnfn mad(float3, float3, float3);
+float4 __ovld __cnfn mad(float4, float4, float4);
+float8 __ovld __cnfn mad(float8, float8, float8);
+float16 __ovld __cnfn mad(float16, float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn mad(double, double, double);
+double2 __ovld __cnfn mad(double2, double2, double2);
+double3 __ovld __cnfn mad(double3, double3, double3);
+double4 __ovld __cnfn mad(double4, double4, double4);
+double8 __ovld __cnfn mad(double8, double8, double8);
+double16 __ovld __cnfn mad(double16, double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn mad(half, half, half);
+half2 __ovld __cnfn mad(half2, half2, half2);
+half3 __ovld __cnfn mad(half3, half3, half3);
+half4 __ovld __cnfn mad(half4, half4, half4);
+half8 __ovld __cnfn mad(half8, half8, half8);
+half16 __ovld __cnfn mad(half16, half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns x if | x | > | y |, y if | y | > | x |, otherwise
+ * fmax(x, y).
+ */
+float __ovld __cnfn maxmag(float, float);
+float2 __ovld __cnfn maxmag(float2, float2);
+float3 __ovld __cnfn maxmag(float3, float3);
+float4 __ovld __cnfn maxmag(float4, float4);
+float8 __ovld __cnfn maxmag(float8, float8);
+float16 __ovld __cnfn maxmag(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn maxmag(double, double);
+double2 __ovld __cnfn maxmag(double2, double2);
+double3 __ovld __cnfn maxmag(double3, double3);
+double4 __ovld __cnfn maxmag(double4, double4);
+double8 __ovld __cnfn maxmag(double8, double8);
+double16 __ovld __cnfn maxmag(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn maxmag(half, half);
+half2 __ovld __cnfn maxmag(half2, half2);
+half3 __ovld __cnfn maxmag(half3, half3);
+half4 __ovld __cnfn maxmag(half4, half4);
+half8 __ovld __cnfn maxmag(half8, half8);
+half16 __ovld __cnfn maxmag(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns x if | x | < | y |, y if | y | < | x |, otherwise
+ * fmin(x, y).
+ */
+float __ovld __cnfn minmag(float, float);
+float2 __ovld __cnfn minmag(float2, float2);
+float3 __ovld __cnfn minmag(float3, float3);
+float4 __ovld __cnfn minmag(float4, float4);
+float8 __ovld __cnfn minmag(float8, float8);
+float16 __ovld __cnfn minmag(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn minmag(double, double);
+double2 __ovld __cnfn minmag(double2, double2);
+double3 __ovld __cnfn minmag(double3, double3);
+double4 __ovld __cnfn minmag(double4, double4);
+double8 __ovld __cnfn minmag(double8, double8);
+double16 __ovld __cnfn minmag(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn minmag(half, half);
+half2 __ovld __cnfn minmag(half2, half2);
+half3 __ovld __cnfn minmag(half3, half3);
+half4 __ovld __cnfn minmag(half4, half4);
+half8 __ovld __cnfn minmag(half8, half8);
+half16 __ovld __cnfn minmag(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Decompose a floating-point number. The modf
+ * function breaks the argument x into integral and
+ * fractional parts, each of which has the same sign as
+ * the argument. It stores the integral part in the object
+ * pointed to by iptr.
+ */
+#if defined(__opencl_c_generic_address_space)
+float __ovld modf(float, float *);
+float2 __ovld modf(float2, float2 *);
+float3 __ovld modf(float3, float3 *);
+float4 __ovld modf(float4, float4 *);
+float8 __ovld modf(float8, float8 *);
+float16 __ovld modf(float16, float16 *);
+#ifdef cl_khr_fp64
+double __ovld modf(double, double *);
+double2 __ovld modf(double2, double2 *);
+double3 __ovld modf(double3, double3 *);
+double4 __ovld modf(double4, double4 *);
+double8 __ovld modf(double8, double8 *);
+double16 __ovld modf(double16, double16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld modf(half, half *);
+half2 __ovld modf(half2, half2 *);
+half3 __ovld modf(half3, half3 *);
+half4 __ovld modf(half4, half4 *);
+half8 __ovld modf(half8, half8 *);
+half16 __ovld modf(half16, half16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld modf(float, __global float *);
+float2 __ovld modf(float2, __global float2 *);
+float3 __ovld modf(float3, __global float3 *);
+float4 __ovld modf(float4, __global float4 *);
+float8 __ovld modf(float8, __global float8 *);
+float16 __ovld modf(float16, __global float16 *);
+float __ovld modf(float, __local float *);
+float2 __ovld modf(float2, __local float2 *);
+float3 __ovld modf(float3, __local float3 *);
+float4 __ovld modf(float4, __local float4 *);
+float8 __ovld modf(float8, __local float8 *);
+float16 __ovld modf(float16, __local float16 *);
+float __ovld modf(float, __private float *);
+float2 __ovld modf(float2, __private float2 *);
+float3 __ovld modf(float3, __private float3 *);
+float4 __ovld modf(float4, __private float4 *);
+float8 __ovld modf(float8, __private float8 *);
+float16 __ovld modf(float16, __private float16 *);
+#ifdef cl_khr_fp64
+double __ovld modf(double, __global double *);
+double2 __ovld modf(double2, __global double2 *);
+double3 __ovld modf(double3, __global double3 *);
+double4 __ovld modf(double4, __global double4 *);
+double8 __ovld modf(double8, __global double8 *);
+double16 __ovld modf(double16, __global double16 *);
+double __ovld modf(double, __local double *);
+double2 __ovld modf(double2, __local double2 *);
+double3 __ovld modf(double3, __local double3 *);
+double4 __ovld modf(double4, __local double4 *);
+double8 __ovld modf(double8, __local double8 *);
+double16 __ovld modf(double16, __local double16 *);
+double __ovld modf(double, __private double *);
+double2 __ovld modf(double2, __private double2 *);
+double3 __ovld modf(double3, __private double3 *);
+double4 __ovld modf(double4, __private double4 *);
+double8 __ovld modf(double8, __private double8 *);
+double16 __ovld modf(double16, __private double16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld modf(half, __global half *);
+half2 __ovld modf(half2, __global half2 *);
+half3 __ovld modf(half3, __global half3 *);
+half4 __ovld modf(half4, __global half4 *);
+half8 __ovld modf(half8, __global half8 *);
+half16 __ovld modf(half16, __global half16 *);
+half __ovld modf(half, __local half *);
+half2 __ovld modf(half2, __local half2 *);
+half3 __ovld modf(half3, __local half3 *);
+half4 __ovld modf(half4, __local half4 *);
+half8 __ovld modf(half8, __local half8 *);
+half16 __ovld modf(half16, __local half16 *);
+half __ovld modf(half, __private half *);
+half2 __ovld modf(half2, __private half2 *);
+half3 __ovld modf(half3, __private half3 *);
+half4 __ovld modf(half4, __private half4 *);
+half8 __ovld modf(half8, __private half8 *);
+half16 __ovld modf(half16, __private half16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Returns a quiet NaN. The nancode may be placed
+ * in the significand of the resulting NaN.
+ */
+float __ovld __cnfn nan(uint);
+float2 __ovld __cnfn nan(uint2);
+float3 __ovld __cnfn nan(uint3);
+float4 __ovld __cnfn nan(uint4);
+float8 __ovld __cnfn nan(uint8);
+float16 __ovld __cnfn nan(uint16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn nan(ulong);
+double2 __ovld __cnfn nan(ulong2);
+double3 __ovld __cnfn nan(ulong3);
+double4 __ovld __cnfn nan(ulong4);
+double8 __ovld __cnfn nan(ulong8);
+double16 __ovld __cnfn nan(ulong16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn nan(ushort);
+half2 __ovld __cnfn nan(ushort2);
+half3 __ovld __cnfn nan(ushort3);
+half4 __ovld __cnfn nan(ushort4);
+half8 __ovld __cnfn nan(ushort8);
+half16 __ovld __cnfn nan(ushort16);
+#endif //cl_khr_fp16
+
+/**
+ * Computes the next representable single-precision
+ * floating-point value following x in the direction of
+ * y. Thus, if y is less than x, nextafter() returns the
+ * largest representable floating-point number less
+ * than x.
+ */
+float __ovld __cnfn nextafter(float, float);
+float2 __ovld __cnfn nextafter(float2, float2);
+float3 __ovld __cnfn nextafter(float3, float3);
+float4 __ovld __cnfn nextafter(float4, float4);
+float8 __ovld __cnfn nextafter(float8, float8);
+float16 __ovld __cnfn nextafter(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn nextafter(double, double);
+double2 __ovld __cnfn nextafter(double2, double2);
+double3 __ovld __cnfn nextafter(double3, double3);
+double4 __ovld __cnfn nextafter(double4, double4);
+double8 __ovld __cnfn nextafter(double8, double8);
+double16 __ovld __cnfn nextafter(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn nextafter(half, half);
+half2 __ovld __cnfn nextafter(half2, half2);
+half3 __ovld __cnfn nextafter(half3, half3);
+half4 __ovld __cnfn nextafter(half4, half4);
+half8 __ovld __cnfn nextafter(half8, half8);
+half16 __ovld __cnfn nextafter(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute x to the power y.
+ */
+float __ovld __cnfn pow(float, float);
+float2 __ovld __cnfn pow(float2, float2);
+float3 __ovld __cnfn pow(float3, float3);
+float4 __ovld __cnfn pow(float4, float4);
+float8 __ovld __cnfn pow(float8, float8);
+float16 __ovld __cnfn pow(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn pow(double, double);
+double2 __ovld __cnfn pow(double2, double2);
+double3 __ovld __cnfn pow(double3, double3);
+double4 __ovld __cnfn pow(double4, double4);
+double8 __ovld __cnfn pow(double8, double8);
+double16 __ovld __cnfn pow(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn pow(half, half);
+half2 __ovld __cnfn pow(half2, half2);
+half3 __ovld __cnfn pow(half3, half3);
+half4 __ovld __cnfn pow(half4, half4);
+half8 __ovld __cnfn pow(half8, half8);
+half16 __ovld __cnfn pow(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute x to the power y, where y is an integer.
+ */
+float __ovld __cnfn pown(float, int);
+float2 __ovld __cnfn pown(float2, int2);
+float3 __ovld __cnfn pown(float3, int3);
+float4 __ovld __cnfn pown(float4, int4);
+float8 __ovld __cnfn pown(float8, int8);
+float16 __ovld __cnfn pown(float16, int16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn pown(double, int);
+double2 __ovld __cnfn pown(double2, int2);
+double3 __ovld __cnfn pown(double3, int3);
+double4 __ovld __cnfn pown(double4, int4);
+double8 __ovld __cnfn pown(double8, int8);
+double16 __ovld __cnfn pown(double16, int16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn pown(half, int);
+half2 __ovld __cnfn pown(half2, int2);
+half3 __ovld __cnfn pown(half3, int3);
+half4 __ovld __cnfn pown(half4, int4);
+half8 __ovld __cnfn pown(half8, int8);
+half16 __ovld __cnfn pown(half16, int16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute x to the power y, where x is >= 0.
+ */
+float __ovld __cnfn powr(float, float);
+float2 __ovld __cnfn powr(float2, float2);
+float3 __ovld __cnfn powr(float3, float3);
+float4 __ovld __cnfn powr(float4, float4);
+float8 __ovld __cnfn powr(float8, float8);
+float16 __ovld __cnfn powr(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn powr(double, double);
+double2 __ovld __cnfn powr(double2, double2);
+double3 __ovld __cnfn powr(double3, double3);
+double4 __ovld __cnfn powr(double4, double4);
+double8 __ovld __cnfn powr(double8, double8);
+double16 __ovld __cnfn powr(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn powr(half, half);
+half2 __ovld __cnfn powr(half2, half2);
+half3 __ovld __cnfn powr(half3, half3);
+half4 __ovld __cnfn powr(half4, half4);
+half8 __ovld __cnfn powr(half8, half8);
+half16 __ovld __cnfn powr(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute the value r such that r = x - n*y, where n
+ * is the integer nearest the exact value of x/y. If there
+ * are two integers closest to x/y, n shall be the even
+ * one. If r is zero, it is given the same sign as x.
+ */
+float __ovld __cnfn remainder(float, float);
+float2 __ovld __cnfn remainder(float2, float2);
+float3 __ovld __cnfn remainder(float3, float3);
+float4 __ovld __cnfn remainder(float4, float4);
+float8 __ovld __cnfn remainder(float8, float8);
+float16 __ovld __cnfn remainder(float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn remainder(double, double);
+double2 __ovld __cnfn remainder(double2, double2);
+double3 __ovld __cnfn remainder(double3, double3);
+double4 __ovld __cnfn remainder(double4, double4);
+double8 __ovld __cnfn remainder(double8, double8);
+double16 __ovld __cnfn remainder(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn remainder(half, half);
+half2 __ovld __cnfn remainder(half2, half2);
+half3 __ovld __cnfn remainder(half3, half3);
+half4 __ovld __cnfn remainder(half4, half4);
+half8 __ovld __cnfn remainder(half8, half8);
+half16 __ovld __cnfn remainder(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * The remquo function computes the value r such
+ * that r = x - n*y, where n is the integer nearest the
+ * exact value of x/y. If there are two integers closest
+ * to x/y, n shall be the even one. If r is zero, it is
+ * given the same sign as x. This is the same value
+ * that is returned by the remainder function.
+ * remquo also calculates the lower seven bits of the
+ * integral quotient x/y, and gives that value the same
+ * sign as x/y. It stores this signed value in the object
+ * pointed to by quo.
+ */
+#if defined(__opencl_c_generic_address_space)
+float __ovld remquo(float, float, int *);
+float2 __ovld remquo(float2, float2, int2 *);
+float3 __ovld remquo(float3, float3, int3 *);
+float4 __ovld remquo(float4, float4, int4 *);
+float8 __ovld remquo(float8, float8, int8 *);
+float16 __ovld remquo(float16, float16, int16 *);
+#ifdef cl_khr_fp64
+double __ovld remquo(double, double, int *);
+double2 __ovld remquo(double2, double2, int2 *);
+double3 __ovld remquo(double3, double3, int3 *);
+double4 __ovld remquo(double4, double4, int4 *);
+double8 __ovld remquo(double8, double8, int8 *);
+double16 __ovld remquo(double16, double16, int16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld remquo(half, half, int *);
+half2 __ovld remquo(half2, half2, int2 *);
+half3 __ovld remquo(half3, half3, int3 *);
+half4 __ovld remquo(half4, half4, int4 *);
+half8 __ovld remquo(half8, half8, int8 *);
+half16 __ovld remquo(half16, half16, int16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld remquo(float, float, __global int *);
+float2 __ovld remquo(float2, float2, __global int2 *);
+float3 __ovld remquo(float3, float3, __global int3 *);
+float4 __ovld remquo(float4, float4, __global int4 *);
+float8 __ovld remquo(float8, float8, __global int8 *);
+float16 __ovld remquo(float16, float16, __global int16 *);
+float __ovld remquo(float, float, __local int *);
+float2 __ovld remquo(float2, float2, __local int2 *);
+float3 __ovld remquo(float3, float3, __local int3 *);
+float4 __ovld remquo(float4, float4, __local int4 *);
+float8 __ovld remquo(float8, float8, __local int8 *);
+float16 __ovld remquo(float16, float16, __local int16 *);
+float __ovld remquo(float, float, __private int *);
+float2 __ovld remquo(float2, float2, __private int2 *);
+float3 __ovld remquo(float3, float3, __private int3 *);
+float4 __ovld remquo(float4, float4, __private int4 *);
+float8 __ovld remquo(float8, float8, __private int8 *);
+float16 __ovld remquo(float16, float16, __private int16 *);
+#ifdef cl_khr_fp64
+double __ovld remquo(double, double, __global int *);
+double2 __ovld remquo(double2, double2, __global int2 *);
+double3 __ovld remquo(double3, double3, __global int3 *);
+double4 __ovld remquo(double4, double4, __global int4 *);
+double8 __ovld remquo(double8, double8, __global int8 *);
+double16 __ovld remquo(double16, double16, __global int16 *);
+double __ovld remquo(double, double, __local int *);
+double2 __ovld remquo(double2, double2, __local int2 *);
+double3 __ovld remquo(double3, double3, __local int3 *);
+double4 __ovld remquo(double4, double4, __local int4 *);
+double8 __ovld remquo(double8, double8, __local int8 *);
+double16 __ovld remquo(double16, double16, __local int16 *);
+double __ovld remquo(double, double, __private int *);
+double2 __ovld remquo(double2, double2, __private int2 *);
+double3 __ovld remquo(double3, double3, __private int3 *);
+double4 __ovld remquo(double4, double4, __private int4 *);
+double8 __ovld remquo(double8, double8, __private int8 *);
+double16 __ovld remquo(double16, double16, __private int16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld remquo(half, half, __global int *);
+half2 __ovld remquo(half2, half2, __global int2 *);
+half3 __ovld remquo(half3, half3, __global int3 *);
+half4 __ovld remquo(half4, half4, __global int4 *);
+half8 __ovld remquo(half8, half8, __global int8 *);
+half16 __ovld remquo(half16, half16, __global int16 *);
+half __ovld remquo(half, half, __local int *);
+half2 __ovld remquo(half2, half2, __local int2 *);
+half3 __ovld remquo(half3, half3, __local int3 *);
+half4 __ovld remquo(half4, half4, __local int4 *);
+half8 __ovld remquo(half8, half8, __local int8 *);
+half16 __ovld remquo(half16, half16, __local int16 *);
+half __ovld remquo(half, half, __private int *);
+half2 __ovld remquo(half2, half2, __private int2 *);
+half3 __ovld remquo(half3, half3, __private int3 *);
+half4 __ovld remquo(half4, half4, __private int4 *);
+half8 __ovld remquo(half8, half8, __private int8 *);
+half16 __ovld remquo(half16, half16, __private int16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+/**
+ * Round to integral value (using round to nearest
+ * even rounding mode) in floating-point format.
+ * Refer to section 7.1 for description of rounding
+ * modes.
+ */
+float __ovld __cnfn rint(float);
+float2 __ovld __cnfn rint(float2);
+float3 __ovld __cnfn rint(float3);
+float4 __ovld __cnfn rint(float4);
+float8 __ovld __cnfn rint(float8);
+float16 __ovld __cnfn rint(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn rint(double);
+double2 __ovld __cnfn rint(double2);
+double3 __ovld __cnfn rint(double3);
+double4 __ovld __cnfn rint(double4);
+double8 __ovld __cnfn rint(double8);
+double16 __ovld __cnfn rint(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn rint(half);
+half2 __ovld __cnfn rint(half2);
+half3 __ovld __cnfn rint(half3);
+half4 __ovld __cnfn rint(half4);
+half8 __ovld __cnfn rint(half8);
+half16 __ovld __cnfn rint(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute x to the power 1/y.
+ */
+float __ovld __cnfn rootn(float, int);
+float2 __ovld __cnfn rootn(float2, int2);
+float3 __ovld __cnfn rootn(float3, int3);
+float4 __ovld __cnfn rootn(float4, int4);
+float8 __ovld __cnfn rootn(float8, int8);
+float16 __ovld __cnfn rootn(float16, int16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn rootn(double, int);
+double2 __ovld __cnfn rootn(double2, int2);
+double3 __ovld __cnfn rootn(double3, int3);
+double4 __ovld __cnfn rootn(double4, int4);
+double8 __ovld __cnfn rootn(double8, int8);
+double16 __ovld __cnfn rootn(double16, int16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn rootn(half, int);
+half2 __ovld __cnfn rootn(half2, int2);
+half3 __ovld __cnfn rootn(half3, int3);
+half4 __ovld __cnfn rootn(half4, int4);
+half8 __ovld __cnfn rootn(half8, int8);
+half16 __ovld __cnfn rootn(half16, int16);
+#endif //cl_khr_fp16
+
+/**
+ * Return the integral value nearest to x rounding
+ * halfway cases away from zero, regardless of the
+ * current rounding direction.
+ */
+float __ovld __cnfn round(float);
+float2 __ovld __cnfn round(float2);
+float3 __ovld __cnfn round(float3);
+float4 __ovld __cnfn round(float4);
+float8 __ovld __cnfn round(float8);
+float16 __ovld __cnfn round(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn round(double);
+double2 __ovld __cnfn round(double2);
+double3 __ovld __cnfn round(double3);
+double4 __ovld __cnfn round(double4);
+double8 __ovld __cnfn round(double8);
+double16 __ovld __cnfn round(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn round(half);
+half2 __ovld __cnfn round(half2);
+half3 __ovld __cnfn round(half3);
+half4 __ovld __cnfn round(half4);
+half8 __ovld __cnfn round(half8);
+half16 __ovld __cnfn round(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute inverse square root.
+ */
+float __ovld __cnfn rsqrt(float);
+float2 __ovld __cnfn rsqrt(float2);
+float3 __ovld __cnfn rsqrt(float3);
+float4 __ovld __cnfn rsqrt(float4);
+float8 __ovld __cnfn rsqrt(float8);
+float16 __ovld __cnfn rsqrt(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn rsqrt(double);
+double2 __ovld __cnfn rsqrt(double2);
+double3 __ovld __cnfn rsqrt(double3);
+double4 __ovld __cnfn rsqrt(double4);
+double8 __ovld __cnfn rsqrt(double8);
+double16 __ovld __cnfn rsqrt(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn rsqrt(half);
+half2 __ovld __cnfn rsqrt(half2);
+half3 __ovld __cnfn rsqrt(half3);
+half4 __ovld __cnfn rsqrt(half4);
+half8 __ovld __cnfn rsqrt(half8);
+half16 __ovld __cnfn rsqrt(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute sine.
+ */
+float __ovld __cnfn sin(float);
+float2 __ovld __cnfn sin(float2);
+float3 __ovld __cnfn sin(float3);
+float4 __ovld __cnfn sin(float4);
+float8 __ovld __cnfn sin(float8);
+float16 __ovld __cnfn sin(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn sin(double);
+double2 __ovld __cnfn sin(double2);
+double3 __ovld __cnfn sin(double3);
+double4 __ovld __cnfn sin(double4);
+double8 __ovld __cnfn sin(double8);
+double16 __ovld __cnfn sin(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn sin(half);
+half2 __ovld __cnfn sin(half2);
+half3 __ovld __cnfn sin(half3);
+half4 __ovld __cnfn sin(half4);
+half8 __ovld __cnfn sin(half8);
+half16 __ovld __cnfn sin(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute sine and cosine of x. The computed sine
+ * is the return value and computed cosine is returned
+ * in cosval.
+ */
+#if defined(__opencl_c_generic_address_space)
+float __ovld sincos(float, float *);
+float2 __ovld sincos(float2, float2 *);
+float3 __ovld sincos(float3, float3 *);
+float4 __ovld sincos(float4, float4 *);
+float8 __ovld sincos(float8, float8 *);
+float16 __ovld sincos(float16, float16 *);
+#ifdef cl_khr_fp64
+double __ovld sincos(double, double *);
+double2 __ovld sincos(double2, double2 *);
+double3 __ovld sincos(double3, double3 *);
+double4 __ovld sincos(double4, double4 *);
+double8 __ovld sincos(double8, double8 *);
+double16 __ovld sincos(double16, double16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld sincos(half, half *);
+half2 __ovld sincos(half2, half2 *);
+half3 __ovld sincos(half3, half3 *);
+half4 __ovld sincos(half4, half4 *);
+half8 __ovld sincos(half8, half8 *);
+half16 __ovld sincos(half16, half16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld sincos(float, __global float *);
+float2 __ovld sincos(float2, __global float2 *);
+float3 __ovld sincos(float3, __global float3 *);
+float4 __ovld sincos(float4, __global float4 *);
+float8 __ovld sincos(float8, __global float8 *);
+float16 __ovld sincos(float16, __global float16 *);
+float __ovld sincos(float, __local float *);
+float2 __ovld sincos(float2, __local float2 *);
+float3 __ovld sincos(float3, __local float3 *);
+float4 __ovld sincos(float4, __local float4 *);
+float8 __ovld sincos(float8, __local float8 *);
+float16 __ovld sincos(float16, __local float16 *);
+float __ovld sincos(float, __private float *);
+float2 __ovld sincos(float2, __private float2 *);
+float3 __ovld sincos(float3, __private float3 *);
+float4 __ovld sincos(float4, __private float4 *);
+float8 __ovld sincos(float8, __private float8 *);
+float16 __ovld sincos(float16, __private float16 *);
+#ifdef cl_khr_fp64
+double __ovld sincos(double, __global double *);
+double2 __ovld sincos(double2, __global double2 *);
+double3 __ovld sincos(double3, __global double3 *);
+double4 __ovld sincos(double4, __global double4 *);
+double8 __ovld sincos(double8, __global double8 *);
+double16 __ovld sincos(double16, __global double16 *);
+double __ovld sincos(double, __local double *);
+double2 __ovld sincos(double2, __local double2 *);
+double3 __ovld sincos(double3, __local double3 *);
+double4 __ovld sincos(double4, __local double4 *);
+double8 __ovld sincos(double8, __local double8 *);
+double16 __ovld sincos(double16, __local double16 *);
+double __ovld sincos(double, __private double *);
+double2 __ovld sincos(double2, __private double2 *);
+double3 __ovld sincos(double3, __private double3 *);
+double4 __ovld sincos(double4, __private double4 *);
+double8 __ovld sincos(double8, __private double8 *);
+double16 __ovld sincos(double16, __private double16 *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld sincos(half, __global half *);
+half2 __ovld sincos(half2, __global half2 *);
+half3 __ovld sincos(half3, __global half3 *);
+half4 __ovld sincos(half4, __global half4 *);
+half8 __ovld sincos(half8, __global half8 *);
+half16 __ovld sincos(half16, __global half16 *);
+half __ovld sincos(half, __local half *);
+half2 __ovld sincos(half2, __local half2 *);
+half3 __ovld sincos(half3, __local half3 *);
+half4 __ovld sincos(half4, __local half4 *);
+half8 __ovld sincos(half8, __local half8 *);
+half16 __ovld sincos(half16, __local half16 *);
+half __ovld sincos(half, __private half *);
+half2 __ovld sincos(half2, __private half2 *);
+half3 __ovld sincos(half3, __private half3 *);
+half4 __ovld sincos(half4, __private half4 *);
+half8 __ovld sincos(half8, __private half8 *);
+half16 __ovld sincos(half16, __private half16 *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Compute hyperbolic sine.
+ */
+float __ovld __cnfn sinh(float);
+float2 __ovld __cnfn sinh(float2);
+float3 __ovld __cnfn sinh(float3);
+float4 __ovld __cnfn sinh(float4);
+float8 __ovld __cnfn sinh(float8);
+float16 __ovld __cnfn sinh(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn sinh(double);
+double2 __ovld __cnfn sinh(double2);
+double3 __ovld __cnfn sinh(double3);
+double4 __ovld __cnfn sinh(double4);
+double8 __ovld __cnfn sinh(double8);
+double16 __ovld __cnfn sinh(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn sinh(half);
+half2 __ovld __cnfn sinh(half2);
+half3 __ovld __cnfn sinh(half3);
+half4 __ovld __cnfn sinh(half4);
+half8 __ovld __cnfn sinh(half8);
+half16 __ovld __cnfn sinh(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute sin (PI * x).
+ */
+float __ovld __cnfn sinpi(float);
+float2 __ovld __cnfn sinpi(float2);
+float3 __ovld __cnfn sinpi(float3);
+float4 __ovld __cnfn sinpi(float4);
+float8 __ovld __cnfn sinpi(float8);
+float16 __ovld __cnfn sinpi(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn sinpi(double);
+double2 __ovld __cnfn sinpi(double2);
+double3 __ovld __cnfn sinpi(double3);
+double4 __ovld __cnfn sinpi(double4);
+double8 __ovld __cnfn sinpi(double8);
+double16 __ovld __cnfn sinpi(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn sinpi(half);
+half2 __ovld __cnfn sinpi(half2);
+half3 __ovld __cnfn sinpi(half3);
+half4 __ovld __cnfn sinpi(half4);
+half8 __ovld __cnfn sinpi(half8);
+half16 __ovld __cnfn sinpi(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute square root.
+ */
+float __ovld __cnfn sqrt(float);
+float2 __ovld __cnfn sqrt(float2);
+float3 __ovld __cnfn sqrt(float3);
+float4 __ovld __cnfn sqrt(float4);
+float8 __ovld __cnfn sqrt(float8);
+float16 __ovld __cnfn sqrt(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn sqrt(double);
+double2 __ovld __cnfn sqrt(double2);
+double3 __ovld __cnfn sqrt(double3);
+double4 __ovld __cnfn sqrt(double4);
+double8 __ovld __cnfn sqrt(double8);
+double16 __ovld __cnfn sqrt(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn sqrt(half);
+half2 __ovld __cnfn sqrt(half2);
+half3 __ovld __cnfn sqrt(half3);
+half4 __ovld __cnfn sqrt(half4);
+half8 __ovld __cnfn sqrt(half8);
+half16 __ovld __cnfn sqrt(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute tangent.
+ */
+float __ovld __cnfn tan(float);
+float2 __ovld __cnfn tan(float2);
+float3 __ovld __cnfn tan(float3);
+float4 __ovld __cnfn tan(float4);
+float8 __ovld __cnfn tan(float8);
+float16 __ovld __cnfn tan(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn tan(double);
+double2 __ovld __cnfn tan(double2);
+double3 __ovld __cnfn tan(double3);
+double4 __ovld __cnfn tan(double4);
+double8 __ovld __cnfn tan(double8);
+double16 __ovld __cnfn tan(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn tan(half);
+half2 __ovld __cnfn tan(half2);
+half3 __ovld __cnfn tan(half3);
+half4 __ovld __cnfn tan(half4);
+half8 __ovld __cnfn tan(half8);
+half16 __ovld __cnfn tan(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute hyperbolic tangent.
+ */
+float __ovld __cnfn tanh(float);
+float2 __ovld __cnfn tanh(float2);
+float3 __ovld __cnfn tanh(float3);
+float4 __ovld __cnfn tanh(float4);
+float8 __ovld __cnfn tanh(float8);
+float16 __ovld __cnfn tanh(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn tanh(double);
+double2 __ovld __cnfn tanh(double2);
+double3 __ovld __cnfn tanh(double3);
+double4 __ovld __cnfn tanh(double4);
+double8 __ovld __cnfn tanh(double8);
+double16 __ovld __cnfn tanh(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn tanh(half);
+half2 __ovld __cnfn tanh(half2);
+half3 __ovld __cnfn tanh(half3);
+half4 __ovld __cnfn tanh(half4);
+half8 __ovld __cnfn tanh(half8);
+half16 __ovld __cnfn tanh(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute tan (PI * x).
+ */
+float __ovld __cnfn tanpi(float);
+float2 __ovld __cnfn tanpi(float2);
+float3 __ovld __cnfn tanpi(float3);
+float4 __ovld __cnfn tanpi(float4);
+float8 __ovld __cnfn tanpi(float8);
+float16 __ovld __cnfn tanpi(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn tanpi(double);
+double2 __ovld __cnfn tanpi(double2);
+double3 __ovld __cnfn tanpi(double3);
+double4 __ovld __cnfn tanpi(double4);
+double8 __ovld __cnfn tanpi(double8);
+double16 __ovld __cnfn tanpi(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn tanpi(half);
+half2 __ovld __cnfn tanpi(half2);
+half3 __ovld __cnfn tanpi(half3);
+half4 __ovld __cnfn tanpi(half4);
+half8 __ovld __cnfn tanpi(half8);
+half16 __ovld __cnfn tanpi(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute the gamma function.
+ */
+float __ovld __cnfn tgamma(float);
+float2 __ovld __cnfn tgamma(float2);
+float3 __ovld __cnfn tgamma(float3);
+float4 __ovld __cnfn tgamma(float4);
+float8 __ovld __cnfn tgamma(float8);
+float16 __ovld __cnfn tgamma(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn tgamma(double);
+double2 __ovld __cnfn tgamma(double2);
+double3 __ovld __cnfn tgamma(double3);
+double4 __ovld __cnfn tgamma(double4);
+double8 __ovld __cnfn tgamma(double8);
+double16 __ovld __cnfn tgamma(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn tgamma(half);
+half2 __ovld __cnfn tgamma(half2);
+half3 __ovld __cnfn tgamma(half3);
+half4 __ovld __cnfn tgamma(half4);
+half8 __ovld __cnfn tgamma(half8);
+half16 __ovld __cnfn tgamma(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Round to integral value using the round to zero
+ * rounding mode.
+ */
+float __ovld __cnfn trunc(float);
+float2 __ovld __cnfn trunc(float2);
+float3 __ovld __cnfn trunc(float3);
+float4 __ovld __cnfn trunc(float4);
+float8 __ovld __cnfn trunc(float8);
+float16 __ovld __cnfn trunc(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn trunc(double);
+double2 __ovld __cnfn trunc(double2);
+double3 __ovld __cnfn trunc(double3);
+double4 __ovld __cnfn trunc(double4);
+double8 __ovld __cnfn trunc(double8);
+double16 __ovld __cnfn trunc(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn trunc(half);
+half2 __ovld __cnfn trunc(half2);
+half3 __ovld __cnfn trunc(half3);
+half4 __ovld __cnfn trunc(half4);
+half8 __ovld __cnfn trunc(half8);
+half16 __ovld __cnfn trunc(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Compute cosine. x must be in the range -2^16 ... +2^16.
+ */
+float __ovld __cnfn half_cos(float);
+float2 __ovld __cnfn half_cos(float2);
+float3 __ovld __cnfn half_cos(float3);
+float4 __ovld __cnfn half_cos(float4);
+float8 __ovld __cnfn half_cos(float8);
+float16 __ovld __cnfn half_cos(float16);
+
+/**
+ * Compute x / y.
+ */
+float __ovld __cnfn half_divide(float, float);
+float2 __ovld __cnfn half_divide(float2, float2);
+float3 __ovld __cnfn half_divide(float3, float3);
+float4 __ovld __cnfn half_divide(float4, float4);
+float8 __ovld __cnfn half_divide(float8, float8);
+float16 __ovld __cnfn half_divide(float16, float16);
+
+/**
+ * Compute the base- e exponential of x.
+ */
+float __ovld __cnfn half_exp(float);
+float2 __ovld __cnfn half_exp(float2);
+float3 __ovld __cnfn half_exp(float3);
+float4 __ovld __cnfn half_exp(float4);
+float8 __ovld __cnfn half_exp(float8);
+float16 __ovld __cnfn half_exp(float16);
+
+/**
+ * Compute the base- 2 exponential of x.
+ */
+float __ovld __cnfn half_exp2(float);
+float2 __ovld __cnfn half_exp2(float2);
+float3 __ovld __cnfn half_exp2(float3);
+float4 __ovld __cnfn half_exp2(float4);
+float8 __ovld __cnfn half_exp2(float8);
+float16 __ovld __cnfn half_exp2(float16);
+
+/**
+ * Compute the base- 10 exponential of x.
+ */
+float __ovld __cnfn half_exp10(float);
+float2 __ovld __cnfn half_exp10(float2);
+float3 __ovld __cnfn half_exp10(float3);
+float4 __ovld __cnfn half_exp10(float4);
+float8 __ovld __cnfn half_exp10(float8);
+float16 __ovld __cnfn half_exp10(float16);
+
+/**
+ * Compute natural logarithm.
+ */
+float __ovld __cnfn half_log(float);
+float2 __ovld __cnfn half_log(float2);
+float3 __ovld __cnfn half_log(float3);
+float4 __ovld __cnfn half_log(float4);
+float8 __ovld __cnfn half_log(float8);
+float16 __ovld __cnfn half_log(float16);
+
+/**
+ * Compute a base 2 logarithm.
+ */
+float __ovld __cnfn half_log2(float);
+float2 __ovld __cnfn half_log2(float2);
+float3 __ovld __cnfn half_log2(float3);
+float4 __ovld __cnfn half_log2(float4);
+float8 __ovld __cnfn half_log2(float8);
+float16 __ovld __cnfn half_log2(float16);
+
+/**
+ * Compute a base 10 logarithm.
+ */
+float __ovld __cnfn half_log10(float);
+float2 __ovld __cnfn half_log10(float2);
+float3 __ovld __cnfn half_log10(float3);
+float4 __ovld __cnfn half_log10(float4);
+float8 __ovld __cnfn half_log10(float8);
+float16 __ovld __cnfn half_log10(float16);
+
+/**
+ * Compute x to the power y, where x is >= 0.
+ */
+float __ovld __cnfn half_powr(float, float);
+float2 __ovld __cnfn half_powr(float2, float2);
+float3 __ovld __cnfn half_powr(float3, float3);
+float4 __ovld __cnfn half_powr(float4, float4);
+float8 __ovld __cnfn half_powr(float8, float8);
+float16 __ovld __cnfn half_powr(float16, float16);
+
+/**
+ * Compute reciprocal.
+ */
+float __ovld __cnfn half_recip(float);
+float2 __ovld __cnfn half_recip(float2);
+float3 __ovld __cnfn half_recip(float3);
+float4 __ovld __cnfn half_recip(float4);
+float8 __ovld __cnfn half_recip(float8);
+float16 __ovld __cnfn half_recip(float16);
+
+/**
+ * Compute inverse square root.
+ */
+float __ovld __cnfn half_rsqrt(float);
+float2 __ovld __cnfn half_rsqrt(float2);
+float3 __ovld __cnfn half_rsqrt(float3);
+float4 __ovld __cnfn half_rsqrt(float4);
+float8 __ovld __cnfn half_rsqrt(float8);
+float16 __ovld __cnfn half_rsqrt(float16);
+
+/**
+ * Compute sine. x must be in the range -2^16 ... +2^16.
+ */
+float __ovld __cnfn half_sin(float);
+float2 __ovld __cnfn half_sin(float2);
+float3 __ovld __cnfn half_sin(float3);
+float4 __ovld __cnfn half_sin(float4);
+float8 __ovld __cnfn half_sin(float8);
+float16 __ovld __cnfn half_sin(float16);
+
+/**
+ * Compute square root.
+ */
+float __ovld __cnfn half_sqrt(float);
+float2 __ovld __cnfn half_sqrt(float2);
+float3 __ovld __cnfn half_sqrt(float3);
+float4 __ovld __cnfn half_sqrt(float4);
+float8 __ovld __cnfn half_sqrt(float8);
+float16 __ovld __cnfn half_sqrt(float16);
+
+/**
+ * Compute tangent. x must be in the range -216 ... +216.
+ */
+float __ovld __cnfn half_tan(float);
+float2 __ovld __cnfn half_tan(float2);
+float3 __ovld __cnfn half_tan(float3);
+float4 __ovld __cnfn half_tan(float4);
+float8 __ovld __cnfn half_tan(float8);
+float16 __ovld __cnfn half_tan(float16);
+
+/**
+ * Compute cosine over an implementation-defined range.
+ * The maximum error is implementation-defined.
+ */
+float __ovld __cnfn native_cos(float);
+float2 __ovld __cnfn native_cos(float2);
+float3 __ovld __cnfn native_cos(float3);
+float4 __ovld __cnfn native_cos(float4);
+float8 __ovld __cnfn native_cos(float8);
+float16 __ovld __cnfn native_cos(float16);
+
+/**
+ * Compute x / y over an implementation-defined range.
+ * The maximum error is implementation-defined.
+ */
+float __ovld __cnfn native_divide(float, float);
+float2 __ovld __cnfn native_divide(float2, float2);
+float3 __ovld __cnfn native_divide(float3, float3);
+float4 __ovld __cnfn native_divide(float4, float4);
+float8 __ovld __cnfn native_divide(float8, float8);
+float16 __ovld __cnfn native_divide(float16, float16);
+
+/**
+ * Compute the base- e exponential of x over an
+ * implementation-defined range. The maximum error is
+ * implementation-defined.
+ */
+float __ovld __cnfn native_exp(float);
+float2 __ovld __cnfn native_exp(float2);
+float3 __ovld __cnfn native_exp(float3);
+float4 __ovld __cnfn native_exp(float4);
+float8 __ovld __cnfn native_exp(float8);
+float16 __ovld __cnfn native_exp(float16);
+
+/**
+ * Compute the base- 2 exponential of x over an
+ * implementation-defined range. The maximum error is
+ * implementation-defined.
+ */
+float __ovld __cnfn native_exp2(float);
+float2 __ovld __cnfn native_exp2(float2);
+float3 __ovld __cnfn native_exp2(float3);
+float4 __ovld __cnfn native_exp2(float4);
+float8 __ovld __cnfn native_exp2(float8);
+float16 __ovld __cnfn native_exp2(float16);
+
+/**
+ * Compute the base- 10 exponential of x over an
+ * implementation-defined range. The maximum error is
+ * implementation-defined.
+ */
+float __ovld __cnfn native_exp10(float);
+float2 __ovld __cnfn native_exp10(float2);
+float3 __ovld __cnfn native_exp10(float3);
+float4 __ovld __cnfn native_exp10(float4);
+float8 __ovld __cnfn native_exp10(float8);
+float16 __ovld __cnfn native_exp10(float16);
+
+/**
+ * Compute natural logarithm over an implementationdefined
+ * range. The maximum error is implementation
+ * defined.
+ */
+float __ovld __cnfn native_log(float);
+float2 __ovld __cnfn native_log(float2);
+float3 __ovld __cnfn native_log(float3);
+float4 __ovld __cnfn native_log(float4);
+float8 __ovld __cnfn native_log(float8);
+float16 __ovld __cnfn native_log(float16);
+
+/**
+ * Compute a base 2 logarithm over an implementationdefined
+ * range. The maximum error is implementationdefined.
+ */
+float __ovld __cnfn native_log2(float);
+float2 __ovld __cnfn native_log2(float2);
+float3 __ovld __cnfn native_log2(float3);
+float4 __ovld __cnfn native_log2(float4);
+float8 __ovld __cnfn native_log2(float8);
+float16 __ovld __cnfn native_log2(float16);
+
+/**
+ * Compute a base 10 logarithm over an implementationdefined
+ * range. The maximum error is implementationdefined.
+ */
+float __ovld __cnfn native_log10(float);
+float2 __ovld __cnfn native_log10(float2);
+float3 __ovld __cnfn native_log10(float3);
+float4 __ovld __cnfn native_log10(float4);
+float8 __ovld __cnfn native_log10(float8);
+float16 __ovld __cnfn native_log10(float16);
+
+/**
+ * Compute x to the power y, where x is >= 0. The range of
+ * x and y are implementation-defined. The maximum error
+ * is implementation-defined.
+ */
+float __ovld __cnfn native_powr(float, float);
+float2 __ovld __cnfn native_powr(float2, float2);
+float3 __ovld __cnfn native_powr(float3, float3);
+float4 __ovld __cnfn native_powr(float4, float4);
+float8 __ovld __cnfn native_powr(float8, float8);
+float16 __ovld __cnfn native_powr(float16, float16);
+
+/**
+ * Compute reciprocal over an implementation-defined
+ * range. The maximum error is implementation-defined.
+ */
+float __ovld __cnfn native_recip(float);
+float2 __ovld __cnfn native_recip(float2);
+float3 __ovld __cnfn native_recip(float3);
+float4 __ovld __cnfn native_recip(float4);
+float8 __ovld __cnfn native_recip(float8);
+float16 __ovld __cnfn native_recip(float16);
+
+/**
+ * Compute inverse square root over an implementationdefined
+ * range. The maximum error is implementationdefined.
+ */
+float __ovld __cnfn native_rsqrt(float);
+float2 __ovld __cnfn native_rsqrt(float2);
+float3 __ovld __cnfn native_rsqrt(float3);
+float4 __ovld __cnfn native_rsqrt(float4);
+float8 __ovld __cnfn native_rsqrt(float8);
+float16 __ovld __cnfn native_rsqrt(float16);
+
+/**
+ * Compute sine over an implementation-defined range.
+ * The maximum error is implementation-defined.
+ */
+float __ovld __cnfn native_sin(float);
+float2 __ovld __cnfn native_sin(float2);
+float3 __ovld __cnfn native_sin(float3);
+float4 __ovld __cnfn native_sin(float4);
+float8 __ovld __cnfn native_sin(float8);
+float16 __ovld __cnfn native_sin(float16);
+
+/**
+ * Compute square root over an implementation-defined
+ * range. The maximum error is implementation-defined.
+ */
+float __ovld __cnfn native_sqrt(float);
+float2 __ovld __cnfn native_sqrt(float2);
+float3 __ovld __cnfn native_sqrt(float3);
+float4 __ovld __cnfn native_sqrt(float4);
+float8 __ovld __cnfn native_sqrt(float8);
+float16 __ovld __cnfn native_sqrt(float16);
+
+/**
+ * Compute tangent over an implementation-defined range.
+ * The maximum error is implementation-defined.
+ */
+float __ovld __cnfn native_tan(float);
+float2 __ovld __cnfn native_tan(float2);
+float3 __ovld __cnfn native_tan(float3);
+float4 __ovld __cnfn native_tan(float4);
+float8 __ovld __cnfn native_tan(float8);
+float16 __ovld __cnfn native_tan(float16);
+
+// OpenCL v1.1 s6.11.3, v1.2 s6.12.3, v2.0 s6.13.3 - Integer Functions
+
+/**
+ * Returns | x |.
+ */
+uchar __ovld __cnfn abs(char);
+uchar __ovld __cnfn abs(uchar);
+uchar2 __ovld __cnfn abs(char2);
+uchar2 __ovld __cnfn abs(uchar2);
+uchar3 __ovld __cnfn abs(char3);
+uchar3 __ovld __cnfn abs(uchar3);
+uchar4 __ovld __cnfn abs(char4);
+uchar4 __ovld __cnfn abs(uchar4);
+uchar8 __ovld __cnfn abs(char8);
+uchar8 __ovld __cnfn abs(uchar8);
+uchar16 __ovld __cnfn abs(char16);
+uchar16 __ovld __cnfn abs(uchar16);
+ushort __ovld __cnfn abs(short);
+ushort __ovld __cnfn abs(ushort);
+ushort2 __ovld __cnfn abs(short2);
+ushort2 __ovld __cnfn abs(ushort2);
+ushort3 __ovld __cnfn abs(short3);
+ushort3 __ovld __cnfn abs(ushort3);
+ushort4 __ovld __cnfn abs(short4);
+ushort4 __ovld __cnfn abs(ushort4);
+ushort8 __ovld __cnfn abs(short8);
+ushort8 __ovld __cnfn abs(ushort8);
+ushort16 __ovld __cnfn abs(short16);
+ushort16 __ovld __cnfn abs(ushort16);
+uint __ovld __cnfn abs(int);
+uint __ovld __cnfn abs(uint);
+uint2 __ovld __cnfn abs(int2);
+uint2 __ovld __cnfn abs(uint2);
+uint3 __ovld __cnfn abs(int3);
+uint3 __ovld __cnfn abs(uint3);
+uint4 __ovld __cnfn abs(int4);
+uint4 __ovld __cnfn abs(uint4);
+uint8 __ovld __cnfn abs(int8);
+uint8 __ovld __cnfn abs(uint8);
+uint16 __ovld __cnfn abs(int16);
+uint16 __ovld __cnfn abs(uint16);
+ulong __ovld __cnfn abs(long);
+ulong __ovld __cnfn abs(ulong);
+ulong2 __ovld __cnfn abs(long2);
+ulong2 __ovld __cnfn abs(ulong2);
+ulong3 __ovld __cnfn abs(long3);
+ulong3 __ovld __cnfn abs(ulong3);
+ulong4 __ovld __cnfn abs(long4);
+ulong4 __ovld __cnfn abs(ulong4);
+ulong8 __ovld __cnfn abs(long8);
+ulong8 __ovld __cnfn abs(ulong8);
+ulong16 __ovld __cnfn abs(long16);
+ulong16 __ovld __cnfn abs(ulong16);
+
+/**
+ * Returns | x - y | without modulo overflow.
+ */
+uchar __ovld __cnfn abs_diff(char, char);
+uchar __ovld __cnfn abs_diff(uchar, uchar);
+uchar2 __ovld __cnfn abs_diff(char2, char2);
+uchar2 __ovld __cnfn abs_diff(uchar2, uchar2);
+uchar3 __ovld __cnfn abs_diff(char3, char3);
+uchar3 __ovld __cnfn abs_diff(uchar3, uchar3);
+uchar4 __ovld __cnfn abs_diff(char4, char4);
+uchar4 __ovld __cnfn abs_diff(uchar4, uchar4);
+uchar8 __ovld __cnfn abs_diff(char8, char8);
+uchar8 __ovld __cnfn abs_diff(uchar8, uchar8);
+uchar16 __ovld __cnfn abs_diff(char16, char16);
+uchar16 __ovld __cnfn abs_diff(uchar16, uchar16);
+ushort __ovld __cnfn abs_diff(short, short);
+ushort __ovld __cnfn abs_diff(ushort, ushort);
+ushort2 __ovld __cnfn abs_diff(short2, short2);
+ushort2 __ovld __cnfn abs_diff(ushort2, ushort2);
+ushort3 __ovld __cnfn abs_diff(short3, short3);
+ushort3 __ovld __cnfn abs_diff(ushort3, ushort3);
+ushort4 __ovld __cnfn abs_diff(short4, short4);
+ushort4 __ovld __cnfn abs_diff(ushort4, ushort4);
+ushort8 __ovld __cnfn abs_diff(short8, short8);
+ushort8 __ovld __cnfn abs_diff(ushort8, ushort8);
+ushort16 __ovld __cnfn abs_diff(short16, short16);
+ushort16 __ovld __cnfn abs_diff(ushort16, ushort16);
+uint __ovld __cnfn abs_diff(int, int);
+uint __ovld __cnfn abs_diff(uint, uint);
+uint2 __ovld __cnfn abs_diff(int2, int2);
+uint2 __ovld __cnfn abs_diff(uint2, uint2);
+uint3 __ovld __cnfn abs_diff(int3, int3);
+uint3 __ovld __cnfn abs_diff(uint3, uint3);
+uint4 __ovld __cnfn abs_diff(int4, int4);
+uint4 __ovld __cnfn abs_diff(uint4, uint4);
+uint8 __ovld __cnfn abs_diff(int8, int8);
+uint8 __ovld __cnfn abs_diff(uint8, uint8);
+uint16 __ovld __cnfn abs_diff(int16, int16);
+uint16 __ovld __cnfn abs_diff(uint16, uint16);
+ulong __ovld __cnfn abs_diff(long, long);
+ulong __ovld __cnfn abs_diff(ulong, ulong);
+ulong2 __ovld __cnfn abs_diff(long2, long2);
+ulong2 __ovld __cnfn abs_diff(ulong2, ulong2);
+ulong3 __ovld __cnfn abs_diff(long3, long3);
+ulong3 __ovld __cnfn abs_diff(ulong3, ulong3);
+ulong4 __ovld __cnfn abs_diff(long4, long4);
+ulong4 __ovld __cnfn abs_diff(ulong4, ulong4);
+ulong8 __ovld __cnfn abs_diff(long8, long8);
+ulong8 __ovld __cnfn abs_diff(ulong8, ulong8);
+ulong16 __ovld __cnfn abs_diff(long16, long16);
+ulong16 __ovld __cnfn abs_diff(ulong16, ulong16);
+
+/**
+ * Returns x + y and saturates the result.
+ */
+char __ovld __cnfn add_sat(char, char);
+uchar __ovld __cnfn add_sat(uchar, uchar);
+char2 __ovld __cnfn add_sat(char2, char2);
+uchar2 __ovld __cnfn add_sat(uchar2, uchar2);
+char3 __ovld __cnfn add_sat(char3, char3);
+uchar3 __ovld __cnfn add_sat(uchar3, uchar3);
+char4 __ovld __cnfn add_sat(char4, char4);
+uchar4 __ovld __cnfn add_sat(uchar4, uchar4);
+char8 __ovld __cnfn add_sat(char8, char8);
+uchar8 __ovld __cnfn add_sat(uchar8, uchar8);
+char16 __ovld __cnfn add_sat(char16, char16);
+uchar16 __ovld __cnfn add_sat(uchar16, uchar16);
+short __ovld __cnfn add_sat(short, short);
+ushort __ovld __cnfn add_sat(ushort, ushort);
+short2 __ovld __cnfn add_sat(short2, short2);
+ushort2 __ovld __cnfn add_sat(ushort2, ushort2);
+short3 __ovld __cnfn add_sat(short3, short3);
+ushort3 __ovld __cnfn add_sat(ushort3, ushort3);
+short4 __ovld __cnfn add_sat(short4, short4);
+ushort4 __ovld __cnfn add_sat(ushort4, ushort4);
+short8 __ovld __cnfn add_sat(short8, short8);
+ushort8 __ovld __cnfn add_sat(ushort8, ushort8);
+short16 __ovld __cnfn add_sat(short16, short16);
+ushort16 __ovld __cnfn add_sat(ushort16, ushort16);
+int __ovld __cnfn add_sat(int, int);
+uint __ovld __cnfn add_sat(uint, uint);
+int2 __ovld __cnfn add_sat(int2, int2);
+uint2 __ovld __cnfn add_sat(uint2, uint2);
+int3 __ovld __cnfn add_sat(int3, int3);
+uint3 __ovld __cnfn add_sat(uint3, uint3);
+int4 __ovld __cnfn add_sat(int4, int4);
+uint4 __ovld __cnfn add_sat(uint4, uint4);
+int8 __ovld __cnfn add_sat(int8, int8);
+uint8 __ovld __cnfn add_sat(uint8, uint8);
+int16 __ovld __cnfn add_sat(int16, int16);
+uint16 __ovld __cnfn add_sat(uint16, uint16);
+long __ovld __cnfn add_sat(long, long);
+ulong __ovld __cnfn add_sat(ulong, ulong);
+long2 __ovld __cnfn add_sat(long2, long2);
+ulong2 __ovld __cnfn add_sat(ulong2, ulong2);
+long3 __ovld __cnfn add_sat(long3, long3);
+ulong3 __ovld __cnfn add_sat(ulong3, ulong3);
+long4 __ovld __cnfn add_sat(long4, long4);
+ulong4 __ovld __cnfn add_sat(ulong4, ulong4);
+long8 __ovld __cnfn add_sat(long8, long8);
+ulong8 __ovld __cnfn add_sat(ulong8, ulong8);
+long16 __ovld __cnfn add_sat(long16, long16);
+ulong16 __ovld __cnfn add_sat(ulong16, ulong16);
+
+/**
+ * Returns (x + y) >> 1. The intermediate sum does
+ * not modulo overflow.
+ */
+char __ovld __cnfn hadd(char, char);
+uchar __ovld __cnfn hadd(uchar, uchar);
+char2 __ovld __cnfn hadd(char2, char2);
+uchar2 __ovld __cnfn hadd(uchar2, uchar2);
+char3 __ovld __cnfn hadd(char3, char3);
+uchar3 __ovld __cnfn hadd(uchar3, uchar3);
+char4 __ovld __cnfn hadd(char4, char4);
+uchar4 __ovld __cnfn hadd(uchar4, uchar4);
+char8 __ovld __cnfn hadd(char8, char8);
+uchar8 __ovld __cnfn hadd(uchar8, uchar8);
+char16 __ovld __cnfn hadd(char16, char16);
+uchar16 __ovld __cnfn hadd(uchar16, uchar16);
+short __ovld __cnfn hadd(short, short);
+ushort __ovld __cnfn hadd(ushort, ushort);
+short2 __ovld __cnfn hadd(short2, short2);
+ushort2 __ovld __cnfn hadd(ushort2, ushort2);
+short3 __ovld __cnfn hadd(short3, short3);
+ushort3 __ovld __cnfn hadd(ushort3, ushort3);
+short4 __ovld __cnfn hadd(short4, short4);
+ushort4 __ovld __cnfn hadd(ushort4, ushort4);
+short8 __ovld __cnfn hadd(short8, short8);
+ushort8 __ovld __cnfn hadd(ushort8, ushort8);
+short16 __ovld __cnfn hadd(short16, short16);
+ushort16 __ovld __cnfn hadd(ushort16, ushort16);
+int __ovld __cnfn hadd(int, int);
+uint __ovld __cnfn hadd(uint, uint);
+int2 __ovld __cnfn hadd(int2, int2);
+uint2 __ovld __cnfn hadd(uint2, uint2);
+int3 __ovld __cnfn hadd(int3, int3);
+uint3 __ovld __cnfn hadd(uint3, uint3);
+int4 __ovld __cnfn hadd(int4, int4);
+uint4 __ovld __cnfn hadd(uint4, uint4);
+int8 __ovld __cnfn hadd(int8, int8);
+uint8 __ovld __cnfn hadd(uint8, uint8);
+int16 __ovld __cnfn hadd(int16, int16);
+uint16 __ovld __cnfn hadd(uint16, uint16);
+long __ovld __cnfn hadd(long, long);
+ulong __ovld __cnfn hadd(ulong, ulong);
+long2 __ovld __cnfn hadd(long2, long2);
+ulong2 __ovld __cnfn hadd(ulong2, ulong2);
+long3 __ovld __cnfn hadd(long3, long3);
+ulong3 __ovld __cnfn hadd(ulong3, ulong3);
+long4 __ovld __cnfn hadd(long4, long4);
+ulong4 __ovld __cnfn hadd(ulong4, ulong4);
+long8 __ovld __cnfn hadd(long8, long8);
+ulong8 __ovld __cnfn hadd(ulong8, ulong8);
+long16 __ovld __cnfn hadd(long16, long16);
+ulong16 __ovld __cnfn hadd(ulong16, ulong16);
+
+/**
+ * Returns (x + y + 1) >> 1. The intermediate sum
+ * does not modulo overflow.
+ */
+char __ovld __cnfn rhadd(char, char);
+uchar __ovld __cnfn rhadd(uchar, uchar);
+char2 __ovld __cnfn rhadd(char2, char2);
+uchar2 __ovld __cnfn rhadd(uchar2, uchar2);
+char3 __ovld __cnfn rhadd(char3, char3);
+uchar3 __ovld __cnfn rhadd(uchar3, uchar3);
+char4 __ovld __cnfn rhadd(char4, char4);
+uchar4 __ovld __cnfn rhadd(uchar4, uchar4);
+char8 __ovld __cnfn rhadd(char8, char8);
+uchar8 __ovld __cnfn rhadd(uchar8, uchar8);
+char16 __ovld __cnfn rhadd(char16, char16);
+uchar16 __ovld __cnfn rhadd(uchar16, uchar16);
+short __ovld __cnfn rhadd(short, short);
+ushort __ovld __cnfn rhadd(ushort, ushort);
+short2 __ovld __cnfn rhadd(short2, short2);
+ushort2 __ovld __cnfn rhadd(ushort2, ushort2);
+short3 __ovld __cnfn rhadd(short3, short3);
+ushort3 __ovld __cnfn rhadd(ushort3, ushort3);
+short4 __ovld __cnfn rhadd(short4, short4);
+ushort4 __ovld __cnfn rhadd(ushort4, ushort4);
+short8 __ovld __cnfn rhadd(short8, short8);
+ushort8 __ovld __cnfn rhadd(ushort8, ushort8);
+short16 __ovld __cnfn rhadd(short16, short16);
+ushort16 __ovld __cnfn rhadd(ushort16, ushort16);
+int __ovld __cnfn rhadd(int, int);
+uint __ovld __cnfn rhadd(uint, uint);
+int2 __ovld __cnfn rhadd(int2, int2);
+uint2 __ovld __cnfn rhadd(uint2, uint2);
+int3 __ovld __cnfn rhadd(int3, int3);
+uint3 __ovld __cnfn rhadd(uint3, uint3);
+int4 __ovld __cnfn rhadd(int4, int4);
+uint4 __ovld __cnfn rhadd(uint4, uint4);
+int8 __ovld __cnfn rhadd(int8, int8);
+uint8 __ovld __cnfn rhadd(uint8, uint8);
+int16 __ovld __cnfn rhadd(int16, int16);
+uint16 __ovld __cnfn rhadd(uint16, uint16);
+long __ovld __cnfn rhadd(long, long);
+ulong __ovld __cnfn rhadd(ulong, ulong);
+long2 __ovld __cnfn rhadd(long2, long2);
+ulong2 __ovld __cnfn rhadd(ulong2, ulong2);
+long3 __ovld __cnfn rhadd(long3, long3);
+ulong3 __ovld __cnfn rhadd(ulong3, ulong3);
+long4 __ovld __cnfn rhadd(long4, long4);
+ulong4 __ovld __cnfn rhadd(ulong4, ulong4);
+long8 __ovld __cnfn rhadd(long8, long8);
+ulong8 __ovld __cnfn rhadd(ulong8, ulong8);
+long16 __ovld __cnfn rhadd(long16, long16);
+ulong16 __ovld __cnfn rhadd(ulong16, ulong16);
+
+/**
+ * Returns min(max(x, minval), maxval).
+ * Results are undefined if minval > maxval.
+ */
+char __ovld __cnfn clamp(char, char, char);
+uchar __ovld __cnfn clamp(uchar, uchar, uchar);
+char2 __ovld __cnfn clamp(char2, char2, char2);
+uchar2 __ovld __cnfn clamp(uchar2, uchar2, uchar2);
+char3 __ovld __cnfn clamp(char3, char3, char3);
+uchar3 __ovld __cnfn clamp(uchar3, uchar3, uchar3);
+char4 __ovld __cnfn clamp(char4, char4, char4);
+uchar4 __ovld __cnfn clamp(uchar4, uchar4, uchar4);
+char8 __ovld __cnfn clamp(char8, char8, char8);
+uchar8 __ovld __cnfn clamp(uchar8, uchar8, uchar8);
+char16 __ovld __cnfn clamp(char16, char16, char16);
+uchar16 __ovld __cnfn clamp(uchar16, uchar16, uchar16);
+short __ovld __cnfn clamp(short, short, short);
+ushort __ovld __cnfn clamp(ushort, ushort, ushort);
+short2 __ovld __cnfn clamp(short2, short2, short2);
+ushort2 __ovld __cnfn clamp(ushort2, ushort2, ushort2);
+short3 __ovld __cnfn clamp(short3, short3, short3);
+ushort3 __ovld __cnfn clamp(ushort3, ushort3, ushort3);
+short4 __ovld __cnfn clamp(short4, short4, short4);
+ushort4 __ovld __cnfn clamp(ushort4, ushort4, ushort4);
+short8 __ovld __cnfn clamp(short8, short8, short8);
+ushort8 __ovld __cnfn clamp(ushort8, ushort8, ushort8);
+short16 __ovld __cnfn clamp(short16, short16, short16);
+ushort16 __ovld __cnfn clamp(ushort16, ushort16, ushort16);
+int __ovld __cnfn clamp(int, int, int);
+uint __ovld __cnfn clamp(uint, uint, uint);
+int2 __ovld __cnfn clamp(int2, int2, int2);
+uint2 __ovld __cnfn clamp(uint2, uint2, uint2);
+int3 __ovld __cnfn clamp(int3, int3, int3);
+uint3 __ovld __cnfn clamp(uint3, uint3, uint3);
+int4 __ovld __cnfn clamp(int4, int4, int4);
+uint4 __ovld __cnfn clamp(uint4, uint4, uint4);
+int8 __ovld __cnfn clamp(int8, int8, int8);
+uint8 __ovld __cnfn clamp(uint8, uint8, uint8);
+int16 __ovld __cnfn clamp(int16, int16, int16);
+uint16 __ovld __cnfn clamp(uint16, uint16, uint16);
+long __ovld __cnfn clamp(long, long, long);
+ulong __ovld __cnfn clamp(ulong, ulong, ulong);
+long2 __ovld __cnfn clamp(long2, long2, long2);
+ulong2 __ovld __cnfn clamp(ulong2, ulong2, ulong2);
+long3 __ovld __cnfn clamp(long3, long3, long3);
+ulong3 __ovld __cnfn clamp(ulong3, ulong3, ulong3);
+long4 __ovld __cnfn clamp(long4, long4, long4);
+ulong4 __ovld __cnfn clamp(ulong4, ulong4, ulong4);
+long8 __ovld __cnfn clamp(long8, long8, long8);
+ulong8 __ovld __cnfn clamp(ulong8, ulong8, ulong8);
+long16 __ovld __cnfn clamp(long16, long16, long16);
+ulong16 __ovld __cnfn clamp(ulong16, ulong16, ulong16);
+char2 __ovld __cnfn clamp(char2, char, char);
+uchar2 __ovld __cnfn clamp(uchar2, uchar, uchar);
+char3 __ovld __cnfn clamp(char3, char, char);
+uchar3 __ovld __cnfn clamp(uchar3, uchar, uchar);
+char4 __ovld __cnfn clamp(char4, char, char);
+uchar4 __ovld __cnfn clamp(uchar4, uchar, uchar);
+char8 __ovld __cnfn clamp(char8, char, char);
+uchar8 __ovld __cnfn clamp(uchar8, uchar, uchar);
+char16 __ovld __cnfn clamp(char16, char, char);
+uchar16 __ovld __cnfn clamp(uchar16, uchar, uchar);
+short2 __ovld __cnfn clamp(short2, short, short);
+ushort2 __ovld __cnfn clamp(ushort2, ushort, ushort);
+short3 __ovld __cnfn clamp(short3, short, short);
+ushort3 __ovld __cnfn clamp(ushort3, ushort, ushort);
+short4 __ovld __cnfn clamp(short4, short, short);
+ushort4 __ovld __cnfn clamp(ushort4, ushort, ushort);
+short8 __ovld __cnfn clamp(short8, short, short);
+ushort8 __ovld __cnfn clamp(ushort8, ushort, ushort);
+short16 __ovld __cnfn clamp(short16, short, short);
+ushort16 __ovld __cnfn clamp(ushort16, ushort, ushort);
+int2 __ovld __cnfn clamp(int2, int, int);
+uint2 __ovld __cnfn clamp(uint2, uint, uint);
+int3 __ovld __cnfn clamp(int3, int, int);
+uint3 __ovld __cnfn clamp(uint3, uint, uint);
+int4 __ovld __cnfn clamp(int4, int, int);
+uint4 __ovld __cnfn clamp(uint4, uint, uint);
+int8 __ovld __cnfn clamp(int8, int, int);
+uint8 __ovld __cnfn clamp(uint8, uint, uint);
+int16 __ovld __cnfn clamp(int16, int, int);
+uint16 __ovld __cnfn clamp(uint16, uint, uint);
+long2 __ovld __cnfn clamp(long2, long, long);
+ulong2 __ovld __cnfn clamp(ulong2, ulong, ulong);
+long3 __ovld __cnfn clamp(long3, long, long);
+ulong3 __ovld __cnfn clamp(ulong3, ulong, ulong);
+long4 __ovld __cnfn clamp(long4, long, long);
+ulong4 __ovld __cnfn clamp(ulong4, ulong, ulong);
+long8 __ovld __cnfn clamp(long8, long, long);
+ulong8 __ovld __cnfn clamp(ulong8, ulong, ulong);
+long16 __ovld __cnfn clamp(long16, long, long);
+ulong16 __ovld __cnfn clamp(ulong16, ulong, ulong);
+
+/**
+ * Returns the number of leading 0-bits in x, starting
+ * at the most significant bit position.
+ */
+char __ovld __cnfn clz(char);
+uchar __ovld __cnfn clz(uchar);
+char2 __ovld __cnfn clz(char2);
+uchar2 __ovld __cnfn clz(uchar2);
+char3 __ovld __cnfn clz(char3);
+uchar3 __ovld __cnfn clz(uchar3);
+char4 __ovld __cnfn clz(char4);
+uchar4 __ovld __cnfn clz(uchar4);
+char8 __ovld __cnfn clz(char8);
+uchar8 __ovld __cnfn clz(uchar8);
+char16 __ovld __cnfn clz(char16);
+uchar16 __ovld __cnfn clz(uchar16);
+short __ovld __cnfn clz(short);
+ushort __ovld __cnfn clz(ushort);
+short2 __ovld __cnfn clz(short2);
+ushort2 __ovld __cnfn clz(ushort2);
+short3 __ovld __cnfn clz(short3);
+ushort3 __ovld __cnfn clz(ushort3);
+short4 __ovld __cnfn clz(short4);
+ushort4 __ovld __cnfn clz(ushort4);
+short8 __ovld __cnfn clz(short8);
+ushort8 __ovld __cnfn clz(ushort8);
+short16 __ovld __cnfn clz(short16);
+ushort16 __ovld __cnfn clz(ushort16);
+int __ovld __cnfn clz(int);
+uint __ovld __cnfn clz(uint);
+int2 __ovld __cnfn clz(int2);
+uint2 __ovld __cnfn clz(uint2);
+int3 __ovld __cnfn clz(int3);
+uint3 __ovld __cnfn clz(uint3);
+int4 __ovld __cnfn clz(int4);
+uint4 __ovld __cnfn clz(uint4);
+int8 __ovld __cnfn clz(int8);
+uint8 __ovld __cnfn clz(uint8);
+int16 __ovld __cnfn clz(int16);
+uint16 __ovld __cnfn clz(uint16);
+long __ovld __cnfn clz(long);
+ulong __ovld __cnfn clz(ulong);
+long2 __ovld __cnfn clz(long2);
+ulong2 __ovld __cnfn clz(ulong2);
+long3 __ovld __cnfn clz(long3);
+ulong3 __ovld __cnfn clz(ulong3);
+long4 __ovld __cnfn clz(long4);
+ulong4 __ovld __cnfn clz(ulong4);
+long8 __ovld __cnfn clz(long8);
+ulong8 __ovld __cnfn clz(ulong8);
+long16 __ovld __cnfn clz(long16);
+ulong16 __ovld __cnfn clz(ulong16);
+
+/**
+ * Returns the count of trailing 0-bits in x. If x is 0,
+ * returns the size in bits of the type of x or
+ * component type of x, if x is a vector.
+ */
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+char __ovld __cnfn ctz(char);
+uchar __ovld __cnfn ctz(uchar);
+char2 __ovld __cnfn ctz(char2);
+uchar2 __ovld __cnfn ctz(uchar2);
+char3 __ovld __cnfn ctz(char3);
+uchar3 __ovld __cnfn ctz(uchar3);
+char4 __ovld __cnfn ctz(char4);
+uchar4 __ovld __cnfn ctz(uchar4);
+char8 __ovld __cnfn ctz(char8);
+uchar8 __ovld __cnfn ctz(uchar8);
+char16 __ovld __cnfn ctz(char16);
+uchar16 __ovld __cnfn ctz(uchar16);
+short __ovld __cnfn ctz(short);
+ushort __ovld __cnfn ctz(ushort);
+short2 __ovld __cnfn ctz(short2);
+ushort2 __ovld __cnfn ctz(ushort2);
+short3 __ovld __cnfn ctz(short3);
+ushort3 __ovld __cnfn ctz(ushort3);
+short4 __ovld __cnfn ctz(short4);
+ushort4 __ovld __cnfn ctz(ushort4);
+short8 __ovld __cnfn ctz(short8);
+ushort8 __ovld __cnfn ctz(ushort8);
+short16 __ovld __cnfn ctz(short16);
+ushort16 __ovld __cnfn ctz(ushort16);
+int __ovld __cnfn ctz(int);
+uint __ovld __cnfn ctz(uint);
+int2 __ovld __cnfn ctz(int2);
+uint2 __ovld __cnfn ctz(uint2);
+int3 __ovld __cnfn ctz(int3);
+uint3 __ovld __cnfn ctz(uint3);
+int4 __ovld __cnfn ctz(int4);
+uint4 __ovld __cnfn ctz(uint4);
+int8 __ovld __cnfn ctz(int8);
+uint8 __ovld __cnfn ctz(uint8);
+int16 __ovld __cnfn ctz(int16);
+uint16 __ovld __cnfn ctz(uint16);
+long __ovld __cnfn ctz(long);
+ulong __ovld __cnfn ctz(ulong);
+long2 __ovld __cnfn ctz(long2);
+ulong2 __ovld __cnfn ctz(ulong2);
+long3 __ovld __cnfn ctz(long3);
+ulong3 __ovld __cnfn ctz(ulong3);
+long4 __ovld __cnfn ctz(long4);
+ulong4 __ovld __cnfn ctz(ulong4);
+long8 __ovld __cnfn ctz(long8);
+ulong8 __ovld __cnfn ctz(ulong8);
+long16 __ovld __cnfn ctz(long16);
+ulong16 __ovld __cnfn ctz(ulong16);
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+/**
+ * Returns mul_hi(a, b) + c.
+ */
+char __ovld __cnfn mad_hi(char, char, char);
+uchar __ovld __cnfn mad_hi(uchar, uchar, uchar);
+char2 __ovld __cnfn mad_hi(char2, char2, char2);
+uchar2 __ovld __cnfn mad_hi(uchar2, uchar2, uchar2);
+char3 __ovld __cnfn mad_hi(char3, char3, char3);
+uchar3 __ovld __cnfn mad_hi(uchar3, uchar3, uchar3);
+char4 __ovld __cnfn mad_hi(char4, char4, char4);
+uchar4 __ovld __cnfn mad_hi(uchar4, uchar4, uchar4);
+char8 __ovld __cnfn mad_hi(char8, char8, char8);
+uchar8 __ovld __cnfn mad_hi(uchar8, uchar8, uchar8);
+char16 __ovld __cnfn mad_hi(char16, char16, char16);
+uchar16 __ovld __cnfn mad_hi(uchar16, uchar16, uchar16);
+short __ovld __cnfn mad_hi(short, short, short);
+ushort __ovld __cnfn mad_hi(ushort, ushort, ushort);
+short2 __ovld __cnfn mad_hi(short2, short2, short2);
+ushort2 __ovld __cnfn mad_hi(ushort2, ushort2, ushort2);
+short3 __ovld __cnfn mad_hi(short3, short3, short3);
+ushort3 __ovld __cnfn mad_hi(ushort3, ushort3, ushort3);
+short4 __ovld __cnfn mad_hi(short4, short4, short4);
+ushort4 __ovld __cnfn mad_hi(ushort4, ushort4, ushort4);
+short8 __ovld __cnfn mad_hi(short8, short8, short8);
+ushort8 __ovld __cnfn mad_hi(ushort8, ushort8, ushort8);
+short16 __ovld __cnfn mad_hi(short16, short16, short16);
+ushort16 __ovld __cnfn mad_hi(ushort16, ushort16, ushort16);
+int __ovld __cnfn mad_hi(int, int, int);
+uint __ovld __cnfn mad_hi(uint, uint, uint);
+int2 __ovld __cnfn mad_hi(int2, int2, int2);
+uint2 __ovld __cnfn mad_hi(uint2, uint2, uint2);
+int3 __ovld __cnfn mad_hi(int3, int3, int3);
+uint3 __ovld __cnfn mad_hi(uint3, uint3, uint3);
+int4 __ovld __cnfn mad_hi(int4, int4, int4);
+uint4 __ovld __cnfn mad_hi(uint4, uint4, uint4);
+int8 __ovld __cnfn mad_hi(int8, int8, int8);
+uint8 __ovld __cnfn mad_hi(uint8, uint8, uint8);
+int16 __ovld __cnfn mad_hi(int16, int16, int16);
+uint16 __ovld __cnfn mad_hi(uint16, uint16, uint16);
+long __ovld __cnfn mad_hi(long, long, long);
+ulong __ovld __cnfn mad_hi(ulong, ulong, ulong);
+long2 __ovld __cnfn mad_hi(long2, long2, long2);
+ulong2 __ovld __cnfn mad_hi(ulong2, ulong2, ulong2);
+long3 __ovld __cnfn mad_hi(long3, long3, long3);
+ulong3 __ovld __cnfn mad_hi(ulong3, ulong3, ulong3);
+long4 __ovld __cnfn mad_hi(long4, long4, long4);
+ulong4 __ovld __cnfn mad_hi(ulong4, ulong4, ulong4);
+long8 __ovld __cnfn mad_hi(long8, long8, long8);
+ulong8 __ovld __cnfn mad_hi(ulong8, ulong8, ulong8);
+long16 __ovld __cnfn mad_hi(long16, long16, long16);
+ulong16 __ovld __cnfn mad_hi(ulong16, ulong16, ulong16);
+
+/**
+ * Returns a * b + c and saturates the result.
+ */
+char __ovld __cnfn mad_sat(char, char, char);
+uchar __ovld __cnfn mad_sat(uchar, uchar, uchar);
+char2 __ovld __cnfn mad_sat(char2, char2, char2);
+uchar2 __ovld __cnfn mad_sat(uchar2, uchar2, uchar2);
+char3 __ovld __cnfn mad_sat(char3, char3, char3);
+uchar3 __ovld __cnfn mad_sat(uchar3, uchar3, uchar3);
+char4 __ovld __cnfn mad_sat(char4, char4, char4);
+uchar4 __ovld __cnfn mad_sat(uchar4, uchar4, uchar4);
+char8 __ovld __cnfn mad_sat(char8, char8, char8);
+uchar8 __ovld __cnfn mad_sat(uchar8, uchar8, uchar8);
+char16 __ovld __cnfn mad_sat(char16, char16, char16);
+uchar16 __ovld __cnfn mad_sat(uchar16, uchar16, uchar16);
+short __ovld __cnfn mad_sat(short, short, short);
+ushort __ovld __cnfn mad_sat(ushort, ushort, ushort);
+short2 __ovld __cnfn mad_sat(short2, short2, short2);
+ushort2 __ovld __cnfn mad_sat(ushort2, ushort2, ushort2);
+short3 __ovld __cnfn mad_sat(short3, short3, short3);
+ushort3 __ovld __cnfn mad_sat(ushort3, ushort3, ushort3);
+short4 __ovld __cnfn mad_sat(short4, short4, short4);
+ushort4 __ovld __cnfn mad_sat(ushort4, ushort4, ushort4);
+short8 __ovld __cnfn mad_sat(short8, short8, short8);
+ushort8 __ovld __cnfn mad_sat(ushort8, ushort8, ushort8);
+short16 __ovld __cnfn mad_sat(short16, short16, short16);
+ushort16 __ovld __cnfn mad_sat(ushort16, ushort16, ushort16);
+int __ovld __cnfn mad_sat(int, int, int);
+uint __ovld __cnfn mad_sat(uint, uint, uint);
+int2 __ovld __cnfn mad_sat(int2, int2, int2);
+uint2 __ovld __cnfn mad_sat(uint2, uint2, uint2);
+int3 __ovld __cnfn mad_sat(int3, int3, int3);
+uint3 __ovld __cnfn mad_sat(uint3, uint3, uint3);
+int4 __ovld __cnfn mad_sat(int4, int4, int4);
+uint4 __ovld __cnfn mad_sat(uint4, uint4, uint4);
+int8 __ovld __cnfn mad_sat(int8, int8, int8);
+uint8 __ovld __cnfn mad_sat(uint8, uint8, uint8);
+int16 __ovld __cnfn mad_sat(int16, int16, int16);
+uint16 __ovld __cnfn mad_sat(uint16, uint16, uint16);
+long __ovld __cnfn mad_sat(long, long, long);
+ulong __ovld __cnfn mad_sat(ulong, ulong, ulong);
+long2 __ovld __cnfn mad_sat(long2, long2, long2);
+ulong2 __ovld __cnfn mad_sat(ulong2, ulong2, ulong2);
+long3 __ovld __cnfn mad_sat(long3, long3, long3);
+ulong3 __ovld __cnfn mad_sat(ulong3, ulong3, ulong3);
+long4 __ovld __cnfn mad_sat(long4, long4, long4);
+ulong4 __ovld __cnfn mad_sat(ulong4, ulong4, ulong4);
+long8 __ovld __cnfn mad_sat(long8, long8, long8);
+ulong8 __ovld __cnfn mad_sat(ulong8, ulong8, ulong8);
+long16 __ovld __cnfn mad_sat(long16, long16, long16);
+ulong16 __ovld __cnfn mad_sat(ulong16, ulong16, ulong16);
+
+/**
+ * Returns y if x < y, otherwise it returns x.
+ */
+char __ovld __cnfn max(char, char);
+uchar __ovld __cnfn max(uchar, uchar);
+char2 __ovld __cnfn max(char2, char2);
+uchar2 __ovld __cnfn max(uchar2, uchar2);
+char3 __ovld __cnfn max(char3, char3);
+uchar3 __ovld __cnfn max(uchar3, uchar3);
+char4 __ovld __cnfn max(char4, char4);
+uchar4 __ovld __cnfn max(uchar4, uchar4);
+char8 __ovld __cnfn max(char8, char8);
+uchar8 __ovld __cnfn max(uchar8, uchar8);
+char16 __ovld __cnfn max(char16, char16);
+uchar16 __ovld __cnfn max(uchar16, uchar16);
+short __ovld __cnfn max(short, short);
+ushort __ovld __cnfn max(ushort, ushort);
+short2 __ovld __cnfn max(short2, short2);
+ushort2 __ovld __cnfn max(ushort2, ushort2);
+short3 __ovld __cnfn max(short3, short3);
+ushort3 __ovld __cnfn max(ushort3, ushort3);
+short4 __ovld __cnfn max(short4, short4);
+ushort4 __ovld __cnfn max(ushort4, ushort4);
+short8 __ovld __cnfn max(short8, short8);
+ushort8 __ovld __cnfn max(ushort8, ushort8);
+short16 __ovld __cnfn max(short16, short16);
+ushort16 __ovld __cnfn max(ushort16, ushort16);
+int __ovld __cnfn max(int, int);
+uint __ovld __cnfn max(uint, uint);
+int2 __ovld __cnfn max(int2, int2);
+uint2 __ovld __cnfn max(uint2, uint2);
+int3 __ovld __cnfn max(int3, int3);
+uint3 __ovld __cnfn max(uint3, uint3);
+int4 __ovld __cnfn max(int4, int4);
+uint4 __ovld __cnfn max(uint4, uint4);
+int8 __ovld __cnfn max(int8, int8);
+uint8 __ovld __cnfn max(uint8, uint8);
+int16 __ovld __cnfn max(int16, int16);
+uint16 __ovld __cnfn max(uint16, uint16);
+long __ovld __cnfn max(long, long);
+ulong __ovld __cnfn max(ulong, ulong);
+long2 __ovld __cnfn max(long2, long2);
+ulong2 __ovld __cnfn max(ulong2, ulong2);
+long3 __ovld __cnfn max(long3, long3);
+ulong3 __ovld __cnfn max(ulong3, ulong3);
+long4 __ovld __cnfn max(long4, long4);
+ulong4 __ovld __cnfn max(ulong4, ulong4);
+long8 __ovld __cnfn max(long8, long8);
+ulong8 __ovld __cnfn max(ulong8, ulong8);
+long16 __ovld __cnfn max(long16, long16);
+ulong16 __ovld __cnfn max(ulong16, ulong16);
+char2 __ovld __cnfn max(char2, char);
+uchar2 __ovld __cnfn max(uchar2, uchar);
+char3 __ovld __cnfn max(char3, char);
+uchar3 __ovld __cnfn max(uchar3, uchar);
+char4 __ovld __cnfn max(char4, char);
+uchar4 __ovld __cnfn max(uchar4, uchar);
+char8 __ovld __cnfn max(char8, char);
+uchar8 __ovld __cnfn max(uchar8, uchar);
+char16 __ovld __cnfn max(char16, char);
+uchar16 __ovld __cnfn max(uchar16, uchar);
+short2 __ovld __cnfn max(short2, short);
+ushort2 __ovld __cnfn max(ushort2, ushort);
+short3 __ovld __cnfn max(short3, short);
+ushort3 __ovld __cnfn max(ushort3, ushort);
+short4 __ovld __cnfn max(short4, short);
+ushort4 __ovld __cnfn max(ushort4, ushort);
+short8 __ovld __cnfn max(short8, short);
+ushort8 __ovld __cnfn max(ushort8, ushort);
+short16 __ovld __cnfn max(short16, short);
+ushort16 __ovld __cnfn max(ushort16, ushort);
+int2 __ovld __cnfn max(int2, int);
+uint2 __ovld __cnfn max(uint2, uint);
+int3 __ovld __cnfn max(int3, int);
+uint3 __ovld __cnfn max(uint3, uint);
+int4 __ovld __cnfn max(int4, int);
+uint4 __ovld __cnfn max(uint4, uint);
+int8 __ovld __cnfn max(int8, int);
+uint8 __ovld __cnfn max(uint8, uint);
+int16 __ovld __cnfn max(int16, int);
+uint16 __ovld __cnfn max(uint16, uint);
+long2 __ovld __cnfn max(long2, long);
+ulong2 __ovld __cnfn max(ulong2, ulong);
+long3 __ovld __cnfn max(long3, long);
+ulong3 __ovld __cnfn max(ulong3, ulong);
+long4 __ovld __cnfn max(long4, long);
+ulong4 __ovld __cnfn max(ulong4, ulong);
+long8 __ovld __cnfn max(long8, long);
+ulong8 __ovld __cnfn max(ulong8, ulong);
+long16 __ovld __cnfn max(long16, long);
+ulong16 __ovld __cnfn max(ulong16, ulong);
+
+/**
+ * Returns y if y < x, otherwise it returns x.
+ */
+char __ovld __cnfn min(char, char);
+uchar __ovld __cnfn min(uchar, uchar);
+char2 __ovld __cnfn min(char2, char2);
+uchar2 __ovld __cnfn min(uchar2, uchar2);
+char3 __ovld __cnfn min(char3, char3);
+uchar3 __ovld __cnfn min(uchar3, uchar3);
+char4 __ovld __cnfn min(char4, char4);
+uchar4 __ovld __cnfn min(uchar4, uchar4);
+char8 __ovld __cnfn min(char8, char8);
+uchar8 __ovld __cnfn min(uchar8, uchar8);
+char16 __ovld __cnfn min(char16, char16);
+uchar16 __ovld __cnfn min(uchar16, uchar16);
+short __ovld __cnfn min(short, short);
+ushort __ovld __cnfn min(ushort, ushort);
+short2 __ovld __cnfn min(short2, short2);
+ushort2 __ovld __cnfn min(ushort2, ushort2);
+short3 __ovld __cnfn min(short3, short3);
+ushort3 __ovld __cnfn min(ushort3, ushort3);
+short4 __ovld __cnfn min(short4, short4);
+ushort4 __ovld __cnfn min(ushort4, ushort4);
+short8 __ovld __cnfn min(short8, short8);
+ushort8 __ovld __cnfn min(ushort8, ushort8);
+short16 __ovld __cnfn min(short16, short16);
+ushort16 __ovld __cnfn min(ushort16, ushort16);
+int __ovld __cnfn min(int, int);
+uint __ovld __cnfn min(uint, uint);
+int2 __ovld __cnfn min(int2, int2);
+uint2 __ovld __cnfn min(uint2, uint2);
+int3 __ovld __cnfn min(int3, int3);
+uint3 __ovld __cnfn min(uint3, uint3);
+int4 __ovld __cnfn min(int4, int4);
+uint4 __ovld __cnfn min(uint4, uint4);
+int8 __ovld __cnfn min(int8, int8);
+uint8 __ovld __cnfn min(uint8, uint8);
+int16 __ovld __cnfn min(int16, int16);
+uint16 __ovld __cnfn min(uint16, uint16);
+long __ovld __cnfn min(long, long);
+ulong __ovld __cnfn min(ulong, ulong);
+long2 __ovld __cnfn min(long2, long2);
+ulong2 __ovld __cnfn min(ulong2, ulong2);
+long3 __ovld __cnfn min(long3, long3);
+ulong3 __ovld __cnfn min(ulong3, ulong3);
+long4 __ovld __cnfn min(long4, long4);
+ulong4 __ovld __cnfn min(ulong4, ulong4);
+long8 __ovld __cnfn min(long8, long8);
+ulong8 __ovld __cnfn min(ulong8, ulong8);
+long16 __ovld __cnfn min(long16, long16);
+ulong16 __ovld __cnfn min(ulong16, ulong16);
+char2 __ovld __cnfn min(char2, char);
+uchar2 __ovld __cnfn min(uchar2, uchar);
+char3 __ovld __cnfn min(char3, char);
+uchar3 __ovld __cnfn min(uchar3, uchar);
+char4 __ovld __cnfn min(char4, char);
+uchar4 __ovld __cnfn min(uchar4, uchar);
+char8 __ovld __cnfn min(char8, char);
+uchar8 __ovld __cnfn min(uchar8, uchar);
+char16 __ovld __cnfn min(char16, char);
+uchar16 __ovld __cnfn min(uchar16, uchar);
+short2 __ovld __cnfn min(short2, short);
+ushort2 __ovld __cnfn min(ushort2, ushort);
+short3 __ovld __cnfn min(short3, short);
+ushort3 __ovld __cnfn min(ushort3, ushort);
+short4 __ovld __cnfn min(short4, short);
+ushort4 __ovld __cnfn min(ushort4, ushort);
+short8 __ovld __cnfn min(short8, short);
+ushort8 __ovld __cnfn min(ushort8, ushort);
+short16 __ovld __cnfn min(short16, short);
+ushort16 __ovld __cnfn min(ushort16, ushort);
+int2 __ovld __cnfn min(int2, int);
+uint2 __ovld __cnfn min(uint2, uint);
+int3 __ovld __cnfn min(int3, int);
+uint3 __ovld __cnfn min(uint3, uint);
+int4 __ovld __cnfn min(int4, int);
+uint4 __ovld __cnfn min(uint4, uint);
+int8 __ovld __cnfn min(int8, int);
+uint8 __ovld __cnfn min(uint8, uint);
+int16 __ovld __cnfn min(int16, int);
+uint16 __ovld __cnfn min(uint16, uint);
+long2 __ovld __cnfn min(long2, long);
+ulong2 __ovld __cnfn min(ulong2, ulong);
+long3 __ovld __cnfn min(long3, long);
+ulong3 __ovld __cnfn min(ulong3, ulong);
+long4 __ovld __cnfn min(long4, long);
+ulong4 __ovld __cnfn min(ulong4, ulong);
+long8 __ovld __cnfn min(long8, long);
+ulong8 __ovld __cnfn min(ulong8, ulong);
+long16 __ovld __cnfn min(long16, long);
+ulong16 __ovld __cnfn min(ulong16, ulong);
+
+/**
+ * Computes x * y and returns the high half of the
+ * product of x and y.
+ */
+char __ovld __cnfn mul_hi(char, char);
+uchar __ovld __cnfn mul_hi(uchar, uchar);
+char2 __ovld __cnfn mul_hi(char2, char2);
+uchar2 __ovld __cnfn mul_hi(uchar2, uchar2);
+char3 __ovld __cnfn mul_hi(char3, char3);
+uchar3 __ovld __cnfn mul_hi(uchar3, uchar3);
+char4 __ovld __cnfn mul_hi(char4, char4);
+uchar4 __ovld __cnfn mul_hi(uchar4, uchar4);
+char8 __ovld __cnfn mul_hi(char8, char8);
+uchar8 __ovld __cnfn mul_hi(uchar8, uchar8);
+char16 __ovld __cnfn mul_hi(char16, char16);
+uchar16 __ovld __cnfn mul_hi(uchar16, uchar16);
+short __ovld __cnfn mul_hi(short, short);
+ushort __ovld __cnfn mul_hi(ushort, ushort);
+short2 __ovld __cnfn mul_hi(short2, short2);
+ushort2 __ovld __cnfn mul_hi(ushort2, ushort2);
+short3 __ovld __cnfn mul_hi(short3, short3);
+ushort3 __ovld __cnfn mul_hi(ushort3, ushort3);
+short4 __ovld __cnfn mul_hi(short4, short4);
+ushort4 __ovld __cnfn mul_hi(ushort4, ushort4);
+short8 __ovld __cnfn mul_hi(short8, short8);
+ushort8 __ovld __cnfn mul_hi(ushort8, ushort8);
+short16 __ovld __cnfn mul_hi(short16, short16);
+ushort16 __ovld __cnfn mul_hi(ushort16, ushort16);
+int __ovld __cnfn mul_hi(int, int);
+uint __ovld __cnfn mul_hi(uint, uint);
+int2 __ovld __cnfn mul_hi(int2, int2);
+uint2 __ovld __cnfn mul_hi(uint2, uint2);
+int3 __ovld __cnfn mul_hi(int3, int3);
+uint3 __ovld __cnfn mul_hi(uint3, uint3);
+int4 __ovld __cnfn mul_hi(int4, int4);
+uint4 __ovld __cnfn mul_hi(uint4, uint4);
+int8 __ovld __cnfn mul_hi(int8, int8);
+uint8 __ovld __cnfn mul_hi(uint8, uint8);
+int16 __ovld __cnfn mul_hi(int16, int16);
+uint16 __ovld __cnfn mul_hi(uint16, uint16);
+long __ovld __cnfn mul_hi(long, long);
+ulong __ovld __cnfn mul_hi(ulong, ulong);
+long2 __ovld __cnfn mul_hi(long2, long2);
+ulong2 __ovld __cnfn mul_hi(ulong2, ulong2);
+long3 __ovld __cnfn mul_hi(long3, long3);
+ulong3 __ovld __cnfn mul_hi(ulong3, ulong3);
+long4 __ovld __cnfn mul_hi(long4, long4);
+ulong4 __ovld __cnfn mul_hi(ulong4, ulong4);
+long8 __ovld __cnfn mul_hi(long8, long8);
+ulong8 __ovld __cnfn mul_hi(ulong8, ulong8);
+long16 __ovld __cnfn mul_hi(long16, long16);
+ulong16 __ovld __cnfn mul_hi(ulong16, ulong16);
+
+/**
+ * For each element in v, the bits are shifted left by
+ * the number of bits given by the corresponding
+ * element in i (subject to usual shift modulo rules
+ * described in section 6.3). Bits shifted off the left
+ * side of the element are shifted back in from the
+ * right.
+ */
+char __ovld __cnfn rotate(char, char);
+uchar __ovld __cnfn rotate(uchar, uchar);
+char2 __ovld __cnfn rotate(char2, char2);
+uchar2 __ovld __cnfn rotate(uchar2, uchar2);
+char3 __ovld __cnfn rotate(char3, char3);
+uchar3 __ovld __cnfn rotate(uchar3, uchar3);
+char4 __ovld __cnfn rotate(char4, char4);
+uchar4 __ovld __cnfn rotate(uchar4, uchar4);
+char8 __ovld __cnfn rotate(char8, char8);
+uchar8 __ovld __cnfn rotate(uchar8, uchar8);
+char16 __ovld __cnfn rotate(char16, char16);
+uchar16 __ovld __cnfn rotate(uchar16, uchar16);
+short __ovld __cnfn rotate(short, short);
+ushort __ovld __cnfn rotate(ushort, ushort);
+short2 __ovld __cnfn rotate(short2, short2);
+ushort2 __ovld __cnfn rotate(ushort2, ushort2);
+short3 __ovld __cnfn rotate(short3, short3);
+ushort3 __ovld __cnfn rotate(ushort3, ushort3);
+short4 __ovld __cnfn rotate(short4, short4);
+ushort4 __ovld __cnfn rotate(ushort4, ushort4);
+short8 __ovld __cnfn rotate(short8, short8);
+ushort8 __ovld __cnfn rotate(ushort8, ushort8);
+short16 __ovld __cnfn rotate(short16, short16);
+ushort16 __ovld __cnfn rotate(ushort16, ushort16);
+int __ovld __cnfn rotate(int, int);
+uint __ovld __cnfn rotate(uint, uint);
+int2 __ovld __cnfn rotate(int2, int2);
+uint2 __ovld __cnfn rotate(uint2, uint2);
+int3 __ovld __cnfn rotate(int3, int3);
+uint3 __ovld __cnfn rotate(uint3, uint3);
+int4 __ovld __cnfn rotate(int4, int4);
+uint4 __ovld __cnfn rotate(uint4, uint4);
+int8 __ovld __cnfn rotate(int8, int8);
+uint8 __ovld __cnfn rotate(uint8, uint8);
+int16 __ovld __cnfn rotate(int16, int16);
+uint16 __ovld __cnfn rotate(uint16, uint16);
+long __ovld __cnfn rotate(long, long);
+ulong __ovld __cnfn rotate(ulong, ulong);
+long2 __ovld __cnfn rotate(long2, long2);
+ulong2 __ovld __cnfn rotate(ulong2, ulong2);
+long3 __ovld __cnfn rotate(long3, long3);
+ulong3 __ovld __cnfn rotate(ulong3, ulong3);
+long4 __ovld __cnfn rotate(long4, long4);
+ulong4 __ovld __cnfn rotate(ulong4, ulong4);
+long8 __ovld __cnfn rotate(long8, long8);
+ulong8 __ovld __cnfn rotate(ulong8, ulong8);
+long16 __ovld __cnfn rotate(long16, long16);
+ulong16 __ovld __cnfn rotate(ulong16, ulong16);
+
+/**
+ * Returns x - y and saturates the result.
+ */
+char __ovld __cnfn sub_sat(char, char);
+uchar __ovld __cnfn sub_sat(uchar, uchar);
+char2 __ovld __cnfn sub_sat(char2, char2);
+uchar2 __ovld __cnfn sub_sat(uchar2, uchar2);
+char3 __ovld __cnfn sub_sat(char3, char3);
+uchar3 __ovld __cnfn sub_sat(uchar3, uchar3);
+char4 __ovld __cnfn sub_sat(char4, char4);
+uchar4 __ovld __cnfn sub_sat(uchar4, uchar4);
+char8 __ovld __cnfn sub_sat(char8, char8);
+uchar8 __ovld __cnfn sub_sat(uchar8, uchar8);
+char16 __ovld __cnfn sub_sat(char16, char16);
+uchar16 __ovld __cnfn sub_sat(uchar16, uchar16);
+short __ovld __cnfn sub_sat(short, short);
+ushort __ovld __cnfn sub_sat(ushort, ushort);
+short2 __ovld __cnfn sub_sat(short2, short2);
+ushort2 __ovld __cnfn sub_sat(ushort2, ushort2);
+short3 __ovld __cnfn sub_sat(short3, short3);
+ushort3 __ovld __cnfn sub_sat(ushort3, ushort3);
+short4 __ovld __cnfn sub_sat(short4, short4);
+ushort4 __ovld __cnfn sub_sat(ushort4, ushort4);
+short8 __ovld __cnfn sub_sat(short8, short8);
+ushort8 __ovld __cnfn sub_sat(ushort8, ushort8);
+short16 __ovld __cnfn sub_sat(short16, short16);
+ushort16 __ovld __cnfn sub_sat(ushort16, ushort16);
+int __ovld __cnfn sub_sat(int, int);
+uint __ovld __cnfn sub_sat(uint, uint);
+int2 __ovld __cnfn sub_sat(int2, int2);
+uint2 __ovld __cnfn sub_sat(uint2, uint2);
+int3 __ovld __cnfn sub_sat(int3, int3);
+uint3 __ovld __cnfn sub_sat(uint3, uint3);
+int4 __ovld __cnfn sub_sat(int4, int4);
+uint4 __ovld __cnfn sub_sat(uint4, uint4);
+int8 __ovld __cnfn sub_sat(int8, int8);
+uint8 __ovld __cnfn sub_sat(uint8, uint8);
+int16 __ovld __cnfn sub_sat(int16, int16);
+uint16 __ovld __cnfn sub_sat(uint16, uint16);
+long __ovld __cnfn sub_sat(long, long);
+ulong __ovld __cnfn sub_sat(ulong, ulong);
+long2 __ovld __cnfn sub_sat(long2, long2);
+ulong2 __ovld __cnfn sub_sat(ulong2, ulong2);
+long3 __ovld __cnfn sub_sat(long3, long3);
+ulong3 __ovld __cnfn sub_sat(ulong3, ulong3);
+long4 __ovld __cnfn sub_sat(long4, long4);
+ulong4 __ovld __cnfn sub_sat(ulong4, ulong4);
+long8 __ovld __cnfn sub_sat(long8, long8);
+ulong8 __ovld __cnfn sub_sat(ulong8, ulong8);
+long16 __ovld __cnfn sub_sat(long16, long16);
+ulong16 __ovld __cnfn sub_sat(ulong16, ulong16);
+
+/**
+ * result[i] = ((short)hi[i] << 8) | lo[i]
+ * result[i] = ((ushort)hi[i] << 8) | lo[i]
+ */
+short __ovld __cnfn upsample(char, uchar);
+ushort __ovld __cnfn upsample(uchar, uchar);
+short2 __ovld __cnfn upsample(char2, uchar2);
+short3 __ovld __cnfn upsample(char3, uchar3);
+short4 __ovld __cnfn upsample(char4, uchar4);
+short8 __ovld __cnfn upsample(char8, uchar8);
+short16 __ovld __cnfn upsample(char16, uchar16);
+ushort2 __ovld __cnfn upsample(uchar2, uchar2);
+ushort3 __ovld __cnfn upsample(uchar3, uchar3);
+ushort4 __ovld __cnfn upsample(uchar4, uchar4);
+ushort8 __ovld __cnfn upsample(uchar8, uchar8);
+ushort16 __ovld __cnfn upsample(uchar16, uchar16);
+
+/**
+ * result[i] = ((int)hi[i] << 16) | lo[i]
+ * result[i] = ((uint)hi[i] << 16) | lo[i]
+ */
+int __ovld __cnfn upsample(short, ushort);
+uint __ovld __cnfn upsample(ushort, ushort);
+int2 __ovld __cnfn upsample(short2, ushort2);
+int3 __ovld __cnfn upsample(short3, ushort3);
+int4 __ovld __cnfn upsample(short4, ushort4);
+int8 __ovld __cnfn upsample(short8, ushort8);
+int16 __ovld __cnfn upsample(short16, ushort16);
+uint2 __ovld __cnfn upsample(ushort2, ushort2);
+uint3 __ovld __cnfn upsample(ushort3, ushort3);
+uint4 __ovld __cnfn upsample(ushort4, ushort4);
+uint8 __ovld __cnfn upsample(ushort8, ushort8);
+uint16 __ovld __cnfn upsample(ushort16, ushort16);
+/**
+ * result[i] = ((long)hi[i] << 32) | lo[i]
+ * result[i] = ((ulong)hi[i] << 32) | lo[i]
+ */
+long __ovld __cnfn upsample(int, uint);
+ulong __ovld __cnfn upsample(uint, uint);
+long2 __ovld __cnfn upsample(int2, uint2);
+long3 __ovld __cnfn upsample(int3, uint3);
+long4 __ovld __cnfn upsample(int4, uint4);
+long8 __ovld __cnfn upsample(int8, uint8);
+long16 __ovld __cnfn upsample(int16, uint16);
+ulong2 __ovld __cnfn upsample(uint2, uint2);
+ulong3 __ovld __cnfn upsample(uint3, uint3);
+ulong4 __ovld __cnfn upsample(uint4, uint4);
+ulong8 __ovld __cnfn upsample(uint8, uint8);
+ulong16 __ovld __cnfn upsample(uint16, uint16);
+
+/*
+ * popcount(x): returns the number of set bit in x
+ */
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+char __ovld __cnfn popcount(char);
+uchar __ovld __cnfn popcount(uchar);
+char2 __ovld __cnfn popcount(char2);
+uchar2 __ovld __cnfn popcount(uchar2);
+char3 __ovld __cnfn popcount(char3);
+uchar3 __ovld __cnfn popcount(uchar3);
+char4 __ovld __cnfn popcount(char4);
+uchar4 __ovld __cnfn popcount(uchar4);
+char8 __ovld __cnfn popcount(char8);
+uchar8 __ovld __cnfn popcount(uchar8);
+char16 __ovld __cnfn popcount(char16);
+uchar16 __ovld __cnfn popcount(uchar16);
+short __ovld __cnfn popcount(short);
+ushort __ovld __cnfn popcount(ushort);
+short2 __ovld __cnfn popcount(short2);
+ushort2 __ovld __cnfn popcount(ushort2);
+short3 __ovld __cnfn popcount(short3);
+ushort3 __ovld __cnfn popcount(ushort3);
+short4 __ovld __cnfn popcount(short4);
+ushort4 __ovld __cnfn popcount(ushort4);
+short8 __ovld __cnfn popcount(short8);
+ushort8 __ovld __cnfn popcount(ushort8);
+short16 __ovld __cnfn popcount(short16);
+ushort16 __ovld __cnfn popcount(ushort16);
+int __ovld __cnfn popcount(int);
+uint __ovld __cnfn popcount(uint);
+int2 __ovld __cnfn popcount(int2);
+uint2 __ovld __cnfn popcount(uint2);
+int3 __ovld __cnfn popcount(int3);
+uint3 __ovld __cnfn popcount(uint3);
+int4 __ovld __cnfn popcount(int4);
+uint4 __ovld __cnfn popcount(uint4);
+int8 __ovld __cnfn popcount(int8);
+uint8 __ovld __cnfn popcount(uint8);
+int16 __ovld __cnfn popcount(int16);
+uint16 __ovld __cnfn popcount(uint16);
+long __ovld __cnfn popcount(long);
+ulong __ovld __cnfn popcount(ulong);
+long2 __ovld __cnfn popcount(long2);
+ulong2 __ovld __cnfn popcount(ulong2);
+long3 __ovld __cnfn popcount(long3);
+ulong3 __ovld __cnfn popcount(ulong3);
+long4 __ovld __cnfn popcount(long4);
+ulong4 __ovld __cnfn popcount(ulong4);
+long8 __ovld __cnfn popcount(long8);
+ulong8 __ovld __cnfn popcount(ulong8);
+long16 __ovld __cnfn popcount(long16);
+ulong16 __ovld __cnfn popcount(ulong16);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+
+/**
+ * Multiply two 24-bit integer values x and y and add
+ * the 32-bit integer result to the 32-bit integer z.
+ * Refer to definition of mul24 to see how the 24-bit
+ * integer multiplication is performed.
+ */
+int __ovld __cnfn mad24(int, int, int);
+uint __ovld __cnfn mad24(uint, uint, uint);
+int2 __ovld __cnfn mad24(int2, int2, int2);
+uint2 __ovld __cnfn mad24(uint2, uint2, uint2);
+int3 __ovld __cnfn mad24(int3, int3, int3);
+uint3 __ovld __cnfn mad24(uint3, uint3, uint3);
+int4 __ovld __cnfn mad24(int4, int4, int4);
+uint4 __ovld __cnfn mad24(uint4, uint4, uint4);
+int8 __ovld __cnfn mad24(int8, int8, int8);
+uint8 __ovld __cnfn mad24(uint8, uint8, uint8);
+int16 __ovld __cnfn mad24(int16, int16, int16);
+uint16 __ovld __cnfn mad24(uint16, uint16, uint16);
+
+/**
+ * Multiply two 24-bit integer values x and y. x and y
+ * are 32-bit integers but only the low 24-bits are used
+ * to perform the multiplication. mul24 should only
+ * be used when values in x and y are in the range [-
+ * 2^23, 2^23-1] if x and y are signed integers and in the
+ * range [0, 2^24-1] if x and y are unsigned integers. If
+ * x and y are not in this range, the multiplication
+ * result is implementation-defined.
+ */
+int __ovld __cnfn mul24(int, int);
+uint __ovld __cnfn mul24(uint, uint);
+int2 __ovld __cnfn mul24(int2, int2);
+uint2 __ovld __cnfn mul24(uint2, uint2);
+int3 __ovld __cnfn mul24(int3, int3);
+uint3 __ovld __cnfn mul24(uint3, uint3);
+int4 __ovld __cnfn mul24(int4, int4);
+uint4 __ovld __cnfn mul24(uint4, uint4);
+int8 __ovld __cnfn mul24(int8, int8);
+uint8 __ovld __cnfn mul24(uint8, uint8);
+int16 __ovld __cnfn mul24(int16, int16);
+uint16 __ovld __cnfn mul24(uint16, uint16);
+
+// OpenCL v1.1 s6.11.4, v1.2 s6.12.4, v2.0 s6.13.4 - Common Functions
+
+/**
+ * Returns fmin(fmax(x, minval), maxval).
+ * Results are undefined if minval > maxval.
+ */
+float __ovld __cnfn clamp(float, float, float);
+float2 __ovld __cnfn clamp(float2, float2, float2);
+float3 __ovld __cnfn clamp(float3, float3, float3);
+float4 __ovld __cnfn clamp(float4, float4, float4);
+float8 __ovld __cnfn clamp(float8, float8, float8);
+float16 __ovld __cnfn clamp(float16, float16, float16);
+float2 __ovld __cnfn clamp(float2, float, float);
+float3 __ovld __cnfn clamp(float3, float, float);
+float4 __ovld __cnfn clamp(float4, float, float);
+float8 __ovld __cnfn clamp(float8, float, float);
+float16 __ovld __cnfn clamp(float16, float, float);
+#ifdef cl_khr_fp64
+double __ovld __cnfn clamp(double, double, double);
+double2 __ovld __cnfn clamp(double2, double2, double2);
+double3 __ovld __cnfn clamp(double3, double3, double3);
+double4 __ovld __cnfn clamp(double4, double4, double4);
+double8 __ovld __cnfn clamp(double8, double8, double8);
+double16 __ovld __cnfn clamp(double16, double16, double16);
+double2 __ovld __cnfn clamp(double2, double, double);
+double3 __ovld __cnfn clamp(double3, double, double);
+double4 __ovld __cnfn clamp(double4, double, double);
+double8 __ovld __cnfn clamp(double8, double, double);
+double16 __ovld __cnfn clamp(double16, double, double);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn clamp(half, half, half);
+half2 __ovld __cnfn clamp(half2, half2, half2);
+half3 __ovld __cnfn clamp(half3, half3, half3);
+half4 __ovld __cnfn clamp(half4, half4, half4);
+half8 __ovld __cnfn clamp(half8, half8, half8);
+half16 __ovld __cnfn clamp(half16, half16, half16);
+half2 __ovld __cnfn clamp(half2, half, half);
+half3 __ovld __cnfn clamp(half3, half, half);
+half4 __ovld __cnfn clamp(half4, half, half);
+half8 __ovld __cnfn clamp(half8, half, half);
+half16 __ovld __cnfn clamp(half16, half, half);
+#endif //cl_khr_fp16
+
+/**
+ * Converts radians to degrees, i.e. (180 / PI) *
+ * radians.
+ */
+float __ovld __cnfn degrees(float);
+float2 __ovld __cnfn degrees(float2);
+float3 __ovld __cnfn degrees(float3);
+float4 __ovld __cnfn degrees(float4);
+float8 __ovld __cnfn degrees(float8);
+float16 __ovld __cnfn degrees(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn degrees(double);
+double2 __ovld __cnfn degrees(double2);
+double3 __ovld __cnfn degrees(double3);
+double4 __ovld __cnfn degrees(double4);
+double8 __ovld __cnfn degrees(double8);
+double16 __ovld __cnfn degrees(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn degrees(half);
+half2 __ovld __cnfn degrees(half2);
+half3 __ovld __cnfn degrees(half3);
+half4 __ovld __cnfn degrees(half4);
+half8 __ovld __cnfn degrees(half8);
+half16 __ovld __cnfn degrees(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns y if x < y, otherwise it returns x. If x and y
+ * are infinite or NaN, the return values are undefined.
+ */
+float __ovld __cnfn max(float, float);
+float2 __ovld __cnfn max(float2, float2);
+float3 __ovld __cnfn max(float3, float3);
+float4 __ovld __cnfn max(float4, float4);
+float8 __ovld __cnfn max(float8, float8);
+float16 __ovld __cnfn max(float16, float16);
+float2 __ovld __cnfn max(float2, float);
+float3 __ovld __cnfn max(float3, float);
+float4 __ovld __cnfn max(float4, float);
+float8 __ovld __cnfn max(float8, float);
+float16 __ovld __cnfn max(float16, float);
+#ifdef cl_khr_fp64
+double __ovld __cnfn max(double, double);
+double2 __ovld __cnfn max(double2, double2);
+double3 __ovld __cnfn max(double3, double3);
+double4 __ovld __cnfn max(double4, double4);
+double8 __ovld __cnfn max(double8, double8);
+double16 __ovld __cnfn max(double16, double16);
+double2 __ovld __cnfn max(double2, double);
+double3 __ovld __cnfn max(double3, double);
+double4 __ovld __cnfn max(double4, double);
+double8 __ovld __cnfn max(double8, double);
+double16 __ovld __cnfn max(double16, double);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn max(half, half);
+half2 __ovld __cnfn max(half2, half2);
+half3 __ovld __cnfn max(half3, half3);
+half4 __ovld __cnfn max(half4, half4);
+half8 __ovld __cnfn max(half8, half8);
+half16 __ovld __cnfn max(half16, half16);
+half2 __ovld __cnfn max(half2, half);
+half3 __ovld __cnfn max(half3, half);
+half4 __ovld __cnfn max(half4, half);
+half8 __ovld __cnfn max(half8, half);
+half16 __ovld __cnfn max(half16, half);
+#endif //cl_khr_fp16
+
+/**
+ * Returns y if y < x, otherwise it returns x. If x and y
+ * are infinite or NaN, the return values are undefined.
+ */
+float __ovld __cnfn min(float, float);
+float2 __ovld __cnfn min(float2, float2);
+float3 __ovld __cnfn min(float3, float3);
+float4 __ovld __cnfn min(float4, float4);
+float8 __ovld __cnfn min(float8, float8);
+float16 __ovld __cnfn min(float16, float16);
+float2 __ovld __cnfn min(float2, float);
+float3 __ovld __cnfn min(float3, float);
+float4 __ovld __cnfn min(float4, float);
+float8 __ovld __cnfn min(float8, float);
+float16 __ovld __cnfn min(float16, float);
+#ifdef cl_khr_fp64
+double __ovld __cnfn min(double, double);
+double2 __ovld __cnfn min(double2, double2);
+double3 __ovld __cnfn min(double3, double3);
+double4 __ovld __cnfn min(double4, double4);
+double8 __ovld __cnfn min(double8, double8);
+double16 __ovld __cnfn min(double16, double16);
+double2 __ovld __cnfn min(double2, double);
+double3 __ovld __cnfn min(double3, double);
+double4 __ovld __cnfn min(double4, double);
+double8 __ovld __cnfn min(double8, double);
+double16 __ovld __cnfn min(double16, double);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn min(half, half);
+half2 __ovld __cnfn min(half2, half2);
+half3 __ovld __cnfn min(half3, half3);
+half4 __ovld __cnfn min(half4, half4);
+half8 __ovld __cnfn min(half8, half8);
+half16 __ovld __cnfn min(half16, half16);
+half2 __ovld __cnfn min(half2, half);
+half3 __ovld __cnfn min(half3, half);
+half4 __ovld __cnfn min(half4, half);
+half8 __ovld __cnfn min(half8, half);
+half16 __ovld __cnfn min(half16, half);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the linear blend of x & y implemented as:
+ * x + (y - x) * a
+ * a must be a value in the range 0.0 ... 1.0. If a is not
+ * in the range 0.0 ... 1.0, the return values are
+ * undefined.
+ */
+float __ovld __cnfn mix(float, float, float);
+float2 __ovld __cnfn mix(float2, float2, float2);
+float3 __ovld __cnfn mix(float3, float3, float3);
+float4 __ovld __cnfn mix(float4, float4, float4);
+float8 __ovld __cnfn mix(float8, float8, float8);
+float16 __ovld __cnfn mix(float16, float16, float16);
+float2 __ovld __cnfn mix(float2, float2, float);
+float3 __ovld __cnfn mix(float3, float3, float);
+float4 __ovld __cnfn mix(float4, float4, float);
+float8 __ovld __cnfn mix(float8, float8, float);
+float16 __ovld __cnfn mix(float16, float16, float);
+#ifdef cl_khr_fp64
+double __ovld __cnfn mix(double, double, double);
+double2 __ovld __cnfn mix(double2, double2, double2);
+double3 __ovld __cnfn mix(double3, double3, double3);
+double4 __ovld __cnfn mix(double4, double4, double4);
+double8 __ovld __cnfn mix(double8, double8, double8);
+double16 __ovld __cnfn mix(double16, double16, double16);
+double2 __ovld __cnfn mix(double2, double2, double);
+double3 __ovld __cnfn mix(double3, double3, double);
+double4 __ovld __cnfn mix(double4, double4, double);
+double8 __ovld __cnfn mix(double8, double8, double);
+double16 __ovld __cnfn mix(double16, double16, double);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn mix(half, half, half);
+half2 __ovld __cnfn mix(half2, half2, half2);
+half3 __ovld __cnfn mix(half3, half3, half3);
+half4 __ovld __cnfn mix(half4, half4, half4);
+half8 __ovld __cnfn mix(half8, half8, half8);
+half16 __ovld __cnfn mix(half16, half16, half16);
+half2 __ovld __cnfn mix(half2, half2, half);
+half3 __ovld __cnfn mix(half3, half3, half);
+half4 __ovld __cnfn mix(half4, half4, half);
+half8 __ovld __cnfn mix(half8, half8, half);
+half16 __ovld __cnfn mix(half16, half16, half);
+#endif //cl_khr_fp16
+
+/**
+ * Converts degrees to radians, i.e. (PI / 180) *
+ * degrees.
+ */
+float __ovld __cnfn radians(float);
+float2 __ovld __cnfn radians(float2);
+float3 __ovld __cnfn radians(float3);
+float4 __ovld __cnfn radians(float4);
+float8 __ovld __cnfn radians(float8);
+float16 __ovld __cnfn radians(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn radians(double);
+double2 __ovld __cnfn radians(double2);
+double3 __ovld __cnfn radians(double3);
+double4 __ovld __cnfn radians(double4);
+double8 __ovld __cnfn radians(double8);
+double16 __ovld __cnfn radians(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn radians(half);
+half2 __ovld __cnfn radians(half2);
+half3 __ovld __cnfn radians(half3);
+half4 __ovld __cnfn radians(half4);
+half8 __ovld __cnfn radians(half8);
+half16 __ovld __cnfn radians(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns 0.0 if x < edge, otherwise it returns 1.0.
+ */
+float __ovld __cnfn step(float, float);
+float2 __ovld __cnfn step(float2, float2);
+float3 __ovld __cnfn step(float3, float3);
+float4 __ovld __cnfn step(float4, float4);
+float8 __ovld __cnfn step(float8, float8);
+float16 __ovld __cnfn step(float16, float16);
+float2 __ovld __cnfn step(float, float2);
+float3 __ovld __cnfn step(float, float3);
+float4 __ovld __cnfn step(float, float4);
+float8 __ovld __cnfn step(float, float8);
+float16 __ovld __cnfn step(float, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn step(double, double);
+double2 __ovld __cnfn step(double2, double2);
+double3 __ovld __cnfn step(double3, double3);
+double4 __ovld __cnfn step(double4, double4);
+double8 __ovld __cnfn step(double8, double8);
+double16 __ovld __cnfn step(double16, double16);
+double2 __ovld __cnfn step(double, double2);
+double3 __ovld __cnfn step(double, double3);
+double4 __ovld __cnfn step(double, double4);
+double8 __ovld __cnfn step(double, double8);
+double16 __ovld __cnfn step(double, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn step(half, half);
+half2 __ovld __cnfn step(half2, half2);
+half3 __ovld __cnfn step(half3, half3);
+half4 __ovld __cnfn step(half4, half4);
+half8 __ovld __cnfn step(half8, half8);
+half16 __ovld __cnfn step(half16, half16);
+half2 __ovld __cnfn step(half, half2);
+half3 __ovld __cnfn step(half, half3);
+half4 __ovld __cnfn step(half, half4);
+half8 __ovld __cnfn step(half, half8);
+half16 __ovld __cnfn step(half, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+ * performs smooth Hermite interpolation between 0
+ * and 1when edge0 < x < edge1. This is useful in
+ * cases where you would want a threshold function
+ * with a smooth transition.
+ * This is equivalent to:
+ * gentype t;
+ * t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
+ * return t * t * (3 - 2 * t);
+ * Results are undefined if edge0 >= edge1 or if x,
+ * edge0 or edge1 is a NaN.
+ */
+float __ovld __cnfn smoothstep(float, float, float);
+float2 __ovld __cnfn smoothstep(float2, float2, float2);
+float3 __ovld __cnfn smoothstep(float3, float3, float3);
+float4 __ovld __cnfn smoothstep(float4, float4, float4);
+float8 __ovld __cnfn smoothstep(float8, float8, float8);
+float16 __ovld __cnfn smoothstep(float16, float16, float16);
+float2 __ovld __cnfn smoothstep(float, float, float2);
+float3 __ovld __cnfn smoothstep(float, float, float3);
+float4 __ovld __cnfn smoothstep(float, float, float4);
+float8 __ovld __cnfn smoothstep(float, float, float8);
+float16 __ovld __cnfn smoothstep(float, float, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn smoothstep(double, double, double);
+double2 __ovld __cnfn smoothstep(double2, double2, double2);
+double3 __ovld __cnfn smoothstep(double3, double3, double3);
+double4 __ovld __cnfn smoothstep(double4, double4, double4);
+double8 __ovld __cnfn smoothstep(double8, double8, double8);
+double16 __ovld __cnfn smoothstep(double16, double16, double16);
+double2 __ovld __cnfn smoothstep(double, double, double2);
+double3 __ovld __cnfn smoothstep(double, double, double3);
+double4 __ovld __cnfn smoothstep(double, double, double4);
+double8 __ovld __cnfn smoothstep(double, double, double8);
+double16 __ovld __cnfn smoothstep(double, double, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn smoothstep(half, half, half);
+half2 __ovld __cnfn smoothstep(half2, half2, half2);
+half3 __ovld __cnfn smoothstep(half3, half3, half3);
+half4 __ovld __cnfn smoothstep(half4, half4, half4);
+half8 __ovld __cnfn smoothstep(half8, half8, half8);
+half16 __ovld __cnfn smoothstep(half16, half16, half16);
+half2 __ovld __cnfn smoothstep(half, half, half2);
+half3 __ovld __cnfn smoothstep(half, half, half3);
+half4 __ovld __cnfn smoothstep(half, half, half4);
+half8 __ovld __cnfn smoothstep(half, half, half8);
+half16 __ovld __cnfn smoothstep(half, half, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns 1.0 if x > 0, -0.0 if x = -0.0, +0.0 if x =
+ * +0.0, or -1.0 if x < 0. Returns 0.0 if x is a NaN.
+ */
+float __ovld __cnfn sign(float);
+float2 __ovld __cnfn sign(float2);
+float3 __ovld __cnfn sign(float3);
+float4 __ovld __cnfn sign(float4);
+float8 __ovld __cnfn sign(float8);
+float16 __ovld __cnfn sign(float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn sign(double);
+double2 __ovld __cnfn sign(double2);
+double3 __ovld __cnfn sign(double3);
+double4 __ovld __cnfn sign(double4);
+double8 __ovld __cnfn sign(double8);
+double16 __ovld __cnfn sign(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn sign(half);
+half2 __ovld __cnfn sign(half2);
+half3 __ovld __cnfn sign(half3);
+half4 __ovld __cnfn sign(half4);
+half8 __ovld __cnfn sign(half8);
+half16 __ovld __cnfn sign(half16);
+#endif //cl_khr_fp16
+
+// OpenCL v1.1 s6.11.5, v1.2 s6.12.5, v2.0 s6.13.5 - Geometric Functions
+
+/**
+ * Returns the cross product of p0.xyz and p1.xyz. The
+ * w component of float4 result returned will be 0.0.
+ */
+float4 __ovld __cnfn cross(float4, float4);
+float3 __ovld __cnfn cross(float3, float3);
+#ifdef cl_khr_fp64
+double4 __ovld __cnfn cross(double4, double4);
+double3 __ovld __cnfn cross(double3, double3);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half4 __ovld __cnfn cross(half4, half4);
+half3 __ovld __cnfn cross(half3, half3);
+#endif //cl_khr_fp16
+
+/**
+ * Compute dot product.
+ */
+float __ovld __cnfn dot(float, float);
+float __ovld __cnfn dot(float2, float2);
+float __ovld __cnfn dot(float3, float3);
+float __ovld __cnfn dot(float4, float4);
+#ifdef cl_khr_fp64
+double __ovld __cnfn dot(double, double);
+double __ovld __cnfn dot(double2, double2);
+double __ovld __cnfn dot(double3, double3);
+double __ovld __cnfn dot(double4, double4);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn dot(half, half);
+half __ovld __cnfn dot(half2, half2);
+half __ovld __cnfn dot(half3, half3);
+half __ovld __cnfn dot(half4, half4);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the distance between p0 and p1. This is
+ * calculated as length(p0 - p1).
+ */
+float __ovld __cnfn distance(float, float);
+float __ovld __cnfn distance(float2, float2);
+float __ovld __cnfn distance(float3, float3);
+float __ovld __cnfn distance(float4, float4);
+#ifdef cl_khr_fp64
+double __ovld __cnfn distance(double, double);
+double __ovld __cnfn distance(double2, double2);
+double __ovld __cnfn distance(double3, double3);
+double __ovld __cnfn distance(double4, double4);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn distance(half, half);
+half __ovld __cnfn distance(half2, half2);
+half __ovld __cnfn distance(half3, half3);
+half __ovld __cnfn distance(half4, half4);
+#endif //cl_khr_fp16
+
+/**
+ * Return the length of vector p, i.e.,
+ * sqrt(p.x2 + p.y 2 + ...)
+ */
+float __ovld __cnfn length(float);
+float __ovld __cnfn length(float2);
+float __ovld __cnfn length(float3);
+float __ovld __cnfn length(float4);
+#ifdef cl_khr_fp64
+double __ovld __cnfn length(double);
+double __ovld __cnfn length(double2);
+double __ovld __cnfn length(double3);
+double __ovld __cnfn length(double4);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn length(half);
+half __ovld __cnfn length(half2);
+half __ovld __cnfn length(half3);
+half __ovld __cnfn length(half4);
+#endif //cl_khr_fp16
+
+/**
+ * Returns a vector in the same direction as p but with a
+ * length of 1.
+ */
+float __ovld __cnfn normalize(float);
+float2 __ovld __cnfn normalize(float2);
+float3 __ovld __cnfn normalize(float3);
+float4 __ovld __cnfn normalize(float4);
+#ifdef cl_khr_fp64
+double __ovld __cnfn normalize(double);
+double2 __ovld __cnfn normalize(double2);
+double3 __ovld __cnfn normalize(double3);
+double4 __ovld __cnfn normalize(double4);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn normalize(half);
+half2 __ovld __cnfn normalize(half2);
+half3 __ovld __cnfn normalize(half3);
+half4 __ovld __cnfn normalize(half4);
+#endif //cl_khr_fp16
+
+/**
+ * Returns fast_length(p0 - p1).
+ */
+float __ovld __cnfn fast_distance(float, float);
+float __ovld __cnfn fast_distance(float2, float2);
+float __ovld __cnfn fast_distance(float3, float3);
+float __ovld __cnfn fast_distance(float4, float4);
+
+/**
+ * Returns the length of vector p computed as:
+ * half_sqrt(p.x2 + p.y2 + ...)
+ */
+float __ovld __cnfn fast_length(float);
+float __ovld __cnfn fast_length(float2);
+float __ovld __cnfn fast_length(float3);
+float __ovld __cnfn fast_length(float4);
+
+/**
+ * Returns a vector in the same direction as p but with a
+ * length of 1. fast_normalize is computed as:
+ * p * half_rsqrt (p.x^2 + p.y^2 + ... )
+ * The result shall be within 8192 ulps error from the
+ * infinitely precise result of
+ * if (all(p == 0.0f))
+ * result = p;
+ * else
+ * result = p / sqrt (p.x^2 + p.y^2 + ...);
+ * with the following exceptions:
+ * 1) If the sum of squares is greater than FLT_MAX
+ * then the value of the floating-point values in the
+ * result vector are undefined.
+ * 2) If the sum of squares is less than FLT_MIN then
+ * the implementation may return back p.
+ * 3) If the device is in "denorms are flushed to zero"
+ * mode, individual operand elements with magnitude
+ * less than sqrt(FLT_MIN) may be flushed to zero
+ * before proceeding with the calculation.
+ */
+float __ovld __cnfn fast_normalize(float);
+float2 __ovld __cnfn fast_normalize(float2);
+float3 __ovld __cnfn fast_normalize(float3);
+float4 __ovld __cnfn fast_normalize(float4);
+
+// OpenCL v1.1 s6.11.6, v1.2 s6.12.6, v2.0 s6.13.6 - Relational Functions
+
+/**
+ * intn isequal (floatn x, floatn y)
+ * Returns the component-wise compare of x == y.
+ */
+int __ovld __cnfn isequal(float, float);
+int2 __ovld __cnfn isequal(float2, float2);
+int3 __ovld __cnfn isequal(float3, float3);
+int4 __ovld __cnfn isequal(float4, float4);
+int8 __ovld __cnfn isequal(float8, float8);
+int16 __ovld __cnfn isequal(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isequal(double, double);
+long2 __ovld __cnfn isequal(double2, double2);
+long3 __ovld __cnfn isequal(double3, double3);
+long4 __ovld __cnfn isequal(double4, double4);
+long8 __ovld __cnfn isequal(double8, double8);
+long16 __ovld __cnfn isequal(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isequal(half, half);
+short2 __ovld __cnfn isequal(half2, half2);
+short3 __ovld __cnfn isequal(half3, half3);
+short4 __ovld __cnfn isequal(half4, half4);
+short8 __ovld __cnfn isequal(half8, half8);
+short16 __ovld __cnfn isequal(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the component-wise compare of x != y.
+ */
+int __ovld __cnfn isnotequal(float, float);
+int2 __ovld __cnfn isnotequal(float2, float2);
+int3 __ovld __cnfn isnotequal(float3, float3);
+int4 __ovld __cnfn isnotequal(float4, float4);
+int8 __ovld __cnfn isnotequal(float8, float8);
+int16 __ovld __cnfn isnotequal(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isnotequal(double, double);
+long2 __ovld __cnfn isnotequal(double2, double2);
+long3 __ovld __cnfn isnotequal(double3, double3);
+long4 __ovld __cnfn isnotequal(double4, double4);
+long8 __ovld __cnfn isnotequal(double8, double8);
+long16 __ovld __cnfn isnotequal(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isnotequal(half, half);
+short2 __ovld __cnfn isnotequal(half2, half2);
+short3 __ovld __cnfn isnotequal(half3, half3);
+short4 __ovld __cnfn isnotequal(half4, half4);
+short8 __ovld __cnfn isnotequal(half8, half8);
+short16 __ovld __cnfn isnotequal(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the component-wise compare of x > y.
+ */
+int __ovld __cnfn isgreater(float, float);
+int2 __ovld __cnfn isgreater(float2, float2);
+int3 __ovld __cnfn isgreater(float3, float3);
+int4 __ovld __cnfn isgreater(float4, float4);
+int8 __ovld __cnfn isgreater(float8, float8);
+int16 __ovld __cnfn isgreater(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isgreater(double, double);
+long2 __ovld __cnfn isgreater(double2, double2);
+long3 __ovld __cnfn isgreater(double3, double3);
+long4 __ovld __cnfn isgreater(double4, double4);
+long8 __ovld __cnfn isgreater(double8, double8);
+long16 __ovld __cnfn isgreater(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isgreater(half, half);
+short2 __ovld __cnfn isgreater(half2, half2);
+short3 __ovld __cnfn isgreater(half3, half3);
+short4 __ovld __cnfn isgreater(half4, half4);
+short8 __ovld __cnfn isgreater(half8, half8);
+short16 __ovld __cnfn isgreater(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the component-wise compare of x >= y.
+ */
+int __ovld __cnfn isgreaterequal(float, float);
+int2 __ovld __cnfn isgreaterequal(float2, float2);
+int3 __ovld __cnfn isgreaterequal(float3, float3);
+int4 __ovld __cnfn isgreaterequal(float4, float4);
+int8 __ovld __cnfn isgreaterequal(float8, float8);
+int16 __ovld __cnfn isgreaterequal(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isgreaterequal(double, double);
+long2 __ovld __cnfn isgreaterequal(double2, double2);
+long3 __ovld __cnfn isgreaterequal(double3, double3);
+long4 __ovld __cnfn isgreaterequal(double4, double4);
+long8 __ovld __cnfn isgreaterequal(double8, double8);
+long16 __ovld __cnfn isgreaterequal(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isgreaterequal(half, half);
+short2 __ovld __cnfn isgreaterequal(half2, half2);
+short3 __ovld __cnfn isgreaterequal(half3, half3);
+short4 __ovld __cnfn isgreaterequal(half4, half4);
+short8 __ovld __cnfn isgreaterequal(half8, half8);
+short16 __ovld __cnfn isgreaterequal(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the component-wise compare of x < y.
+ */
+int __ovld __cnfn isless(float, float);
+int2 __ovld __cnfn isless(float2, float2);
+int3 __ovld __cnfn isless(float3, float3);
+int4 __ovld __cnfn isless(float4, float4);
+int8 __ovld __cnfn isless(float8, float8);
+int16 __ovld __cnfn isless(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isless(double, double);
+long2 __ovld __cnfn isless(double2, double2);
+long3 __ovld __cnfn isless(double3, double3);
+long4 __ovld __cnfn isless(double4, double4);
+long8 __ovld __cnfn isless(double8, double8);
+long16 __ovld __cnfn isless(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isless(half, half);
+short2 __ovld __cnfn isless(half2, half2);
+short3 __ovld __cnfn isless(half3, half3);
+short4 __ovld __cnfn isless(half4, half4);
+short8 __ovld __cnfn isless(half8, half8);
+short16 __ovld __cnfn isless(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the component-wise compare of x <= y.
+ */
+int __ovld __cnfn islessequal(float, float);
+int2 __ovld __cnfn islessequal(float2, float2);
+int3 __ovld __cnfn islessequal(float3, float3);
+int4 __ovld __cnfn islessequal(float4, float4);
+int8 __ovld __cnfn islessequal(float8, float8);
+int16 __ovld __cnfn islessequal(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn islessequal(double, double);
+long2 __ovld __cnfn islessequal(double2, double2);
+long3 __ovld __cnfn islessequal(double3, double3);
+long4 __ovld __cnfn islessequal(double4, double4);
+long8 __ovld __cnfn islessequal(double8, double8);
+long16 __ovld __cnfn islessequal(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn islessequal(half, half);
+short2 __ovld __cnfn islessequal(half2, half2);
+short3 __ovld __cnfn islessequal(half3, half3);
+short4 __ovld __cnfn islessequal(half4, half4);
+short8 __ovld __cnfn islessequal(half8, half8);
+short16 __ovld __cnfn islessequal(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns the component-wise compare of
+ * (x < y) || (x > y) .
+ */
+int __ovld __cnfn islessgreater(float, float);
+int2 __ovld __cnfn islessgreater(float2, float2);
+int3 __ovld __cnfn islessgreater(float3, float3);
+int4 __ovld __cnfn islessgreater(float4, float4);
+int8 __ovld __cnfn islessgreater(float8, float8);
+int16 __ovld __cnfn islessgreater(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn islessgreater(double, double);
+long2 __ovld __cnfn islessgreater(double2, double2);
+long3 __ovld __cnfn islessgreater(double3, double3);
+long4 __ovld __cnfn islessgreater(double4, double4);
+long8 __ovld __cnfn islessgreater(double8, double8);
+long16 __ovld __cnfn islessgreater(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn islessgreater(half, half);
+short2 __ovld __cnfn islessgreater(half2, half2);
+short3 __ovld __cnfn islessgreater(half3, half3);
+short4 __ovld __cnfn islessgreater(half4, half4);
+short8 __ovld __cnfn islessgreater(half8, half8);
+short16 __ovld __cnfn islessgreater(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test for finite value.
+ */
+int __ovld __cnfn isfinite(float);
+int2 __ovld __cnfn isfinite(float2);
+int3 __ovld __cnfn isfinite(float3);
+int4 __ovld __cnfn isfinite(float4);
+int8 __ovld __cnfn isfinite(float8);
+int16 __ovld __cnfn isfinite(float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isfinite(double);
+long2 __ovld __cnfn isfinite(double2);
+long3 __ovld __cnfn isfinite(double3);
+long4 __ovld __cnfn isfinite(double4);
+long8 __ovld __cnfn isfinite(double8);
+long16 __ovld __cnfn isfinite(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isfinite(half);
+short2 __ovld __cnfn isfinite(half2);
+short3 __ovld __cnfn isfinite(half3);
+short4 __ovld __cnfn isfinite(half4);
+short8 __ovld __cnfn isfinite(half8);
+short16 __ovld __cnfn isfinite(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test for infinity value (+ve or -ve) .
+ */
+int __ovld __cnfn isinf(float);
+int2 __ovld __cnfn isinf(float2);
+int3 __ovld __cnfn isinf(float3);
+int4 __ovld __cnfn isinf(float4);
+int8 __ovld __cnfn isinf(float8);
+int16 __ovld __cnfn isinf(float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isinf(double);
+long2 __ovld __cnfn isinf(double2);
+long3 __ovld __cnfn isinf(double3);
+long4 __ovld __cnfn isinf(double4);
+long8 __ovld __cnfn isinf(double8);
+long16 __ovld __cnfn isinf(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isinf(half);
+short2 __ovld __cnfn isinf(half2);
+short3 __ovld __cnfn isinf(half3);
+short4 __ovld __cnfn isinf(half4);
+short8 __ovld __cnfn isinf(half8);
+short16 __ovld __cnfn isinf(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test for a NaN.
+ */
+int __ovld __cnfn isnan(float);
+int2 __ovld __cnfn isnan(float2);
+int3 __ovld __cnfn isnan(float3);
+int4 __ovld __cnfn isnan(float4);
+int8 __ovld __cnfn isnan(float8);
+int16 __ovld __cnfn isnan(float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isnan(double);
+long2 __ovld __cnfn isnan(double2);
+long3 __ovld __cnfn isnan(double3);
+long4 __ovld __cnfn isnan(double4);
+long8 __ovld __cnfn isnan(double8);
+long16 __ovld __cnfn isnan(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isnan(half);
+short2 __ovld __cnfn isnan(half2);
+short3 __ovld __cnfn isnan(half3);
+short4 __ovld __cnfn isnan(half4);
+short8 __ovld __cnfn isnan(half8);
+short16 __ovld __cnfn isnan(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test for a normal value.
+ */
+int __ovld __cnfn isnormal(float);
+int2 __ovld __cnfn isnormal(float2);
+int3 __ovld __cnfn isnormal(float3);
+int4 __ovld __cnfn isnormal(float4);
+int8 __ovld __cnfn isnormal(float8);
+int16 __ovld __cnfn isnormal(float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isnormal(double);
+long2 __ovld __cnfn isnormal(double2);
+long3 __ovld __cnfn isnormal(double3);
+long4 __ovld __cnfn isnormal(double4);
+long8 __ovld __cnfn isnormal(double8);
+long16 __ovld __cnfn isnormal(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isnormal(half);
+short2 __ovld __cnfn isnormal(half2);
+short3 __ovld __cnfn isnormal(half3);
+short4 __ovld __cnfn isnormal(half4);
+short8 __ovld __cnfn isnormal(half8);
+short16 __ovld __cnfn isnormal(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test if arguments are ordered. isordered() takes
+ * arguments x and y, and returns the result
+ * isequal(x, x) && isequal(y, y).
+ */
+int __ovld __cnfn isordered(float, float);
+int2 __ovld __cnfn isordered(float2, float2);
+int3 __ovld __cnfn isordered(float3, float3);
+int4 __ovld __cnfn isordered(float4, float4);
+int8 __ovld __cnfn isordered(float8, float8);
+int16 __ovld __cnfn isordered(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isordered(double, double);
+long2 __ovld __cnfn isordered(double2, double2);
+long3 __ovld __cnfn isordered(double3, double3);
+long4 __ovld __cnfn isordered(double4, double4);
+long8 __ovld __cnfn isordered(double8, double8);
+long16 __ovld __cnfn isordered(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isordered(half, half);
+short2 __ovld __cnfn isordered(half2, half2);
+short3 __ovld __cnfn isordered(half3, half3);
+short4 __ovld __cnfn isordered(half4, half4);
+short8 __ovld __cnfn isordered(half8, half8);
+short16 __ovld __cnfn isordered(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test if arguments are unordered. isunordered()
+ * takes arguments x and y, returning non-zero if x or y
+ * is NaN, and zero otherwise.
+ */
+int __ovld __cnfn isunordered(float, float);
+int2 __ovld __cnfn isunordered(float2, float2);
+int3 __ovld __cnfn isunordered(float3, float3);
+int4 __ovld __cnfn isunordered(float4, float4);
+int8 __ovld __cnfn isunordered(float8, float8);
+int16 __ovld __cnfn isunordered(float16, float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn isunordered(double, double);
+long2 __ovld __cnfn isunordered(double2, double2);
+long3 __ovld __cnfn isunordered(double3, double3);
+long4 __ovld __cnfn isunordered(double4, double4);
+long8 __ovld __cnfn isunordered(double8, double8);
+long16 __ovld __cnfn isunordered(double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn isunordered(half, half);
+short2 __ovld __cnfn isunordered(half2, half2);
+short3 __ovld __cnfn isunordered(half3, half3);
+short4 __ovld __cnfn isunordered(half4, half4);
+short8 __ovld __cnfn isunordered(half8, half8);
+short16 __ovld __cnfn isunordered(half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * Test for sign bit. The scalar version of the function
+ * returns a 1 if the sign bit in the float is set else returns
+ * 0. The vector version of the function returns the
+ * following for each component in floatn: a -1 if the
+ * sign bit in the float is set else returns 0.
+ */
+int __ovld __cnfn signbit(float);
+int2 __ovld __cnfn signbit(float2);
+int3 __ovld __cnfn signbit(float3);
+int4 __ovld __cnfn signbit(float4);
+int8 __ovld __cnfn signbit(float8);
+int16 __ovld __cnfn signbit(float16);
+#ifdef cl_khr_fp64
+int __ovld __cnfn signbit(double);
+long2 __ovld __cnfn signbit(double2);
+long3 __ovld __cnfn signbit(double3);
+long4 __ovld __cnfn signbit(double4);
+long8 __ovld __cnfn signbit(double8);
+long16 __ovld __cnfn signbit(double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+int __ovld __cnfn signbit(half);
+short2 __ovld __cnfn signbit(half2);
+short3 __ovld __cnfn signbit(half3);
+short4 __ovld __cnfn signbit(half4);
+short8 __ovld __cnfn signbit(half8);
+short16 __ovld __cnfn signbit(half16);
+#endif //cl_khr_fp16
+
+/**
+ * Returns 1 if the most significant bit in any component
+ * of x is set; otherwise returns 0.
+ */
+int __ovld __cnfn any(char);
+int __ovld __cnfn any(char2);
+int __ovld __cnfn any(char3);
+int __ovld __cnfn any(char4);
+int __ovld __cnfn any(char8);
+int __ovld __cnfn any(char16);
+int __ovld __cnfn any(short);
+int __ovld __cnfn any(short2);
+int __ovld __cnfn any(short3);
+int __ovld __cnfn any(short4);
+int __ovld __cnfn any(short8);
+int __ovld __cnfn any(short16);
+int __ovld __cnfn any(int);
+int __ovld __cnfn any(int2);
+int __ovld __cnfn any(int3);
+int __ovld __cnfn any(int4);
+int __ovld __cnfn any(int8);
+int __ovld __cnfn any(int16);
+int __ovld __cnfn any(long);
+int __ovld __cnfn any(long2);
+int __ovld __cnfn any(long3);
+int __ovld __cnfn any(long4);
+int __ovld __cnfn any(long8);
+int __ovld __cnfn any(long16);
+
+/**
+ * Returns 1 if the most significant bit in all components
+ * of x is set; otherwise returns 0.
+ */
+int __ovld __cnfn all(char);
+int __ovld __cnfn all(char2);
+int __ovld __cnfn all(char3);
+int __ovld __cnfn all(char4);
+int __ovld __cnfn all(char8);
+int __ovld __cnfn all(char16);
+int __ovld __cnfn all(short);
+int __ovld __cnfn all(short2);
+int __ovld __cnfn all(short3);
+int __ovld __cnfn all(short4);
+int __ovld __cnfn all(short8);
+int __ovld __cnfn all(short16);
+int __ovld __cnfn all(int);
+int __ovld __cnfn all(int2);
+int __ovld __cnfn all(int3);
+int __ovld __cnfn all(int4);
+int __ovld __cnfn all(int8);
+int __ovld __cnfn all(int16);
+int __ovld __cnfn all(long);
+int __ovld __cnfn all(long2);
+int __ovld __cnfn all(long3);
+int __ovld __cnfn all(long4);
+int __ovld __cnfn all(long8);
+int __ovld __cnfn all(long16);
+
+/**
+ * Each bit of the result is the corresponding bit of a if
+ * the corresponding bit of c is 0. Otherwise it is the
+ * corresponding bit of b.
+ */
+char __ovld __cnfn bitselect(char, char, char);
+uchar __ovld __cnfn bitselect(uchar, uchar, uchar);
+char2 __ovld __cnfn bitselect(char2, char2, char2);
+uchar2 __ovld __cnfn bitselect(uchar2, uchar2, uchar2);
+char3 __ovld __cnfn bitselect(char3, char3, char3);
+uchar3 __ovld __cnfn bitselect(uchar3, uchar3, uchar3);
+char4 __ovld __cnfn bitselect(char4, char4, char4);
+uchar4 __ovld __cnfn bitselect(uchar4, uchar4, uchar4);
+char8 __ovld __cnfn bitselect(char8, char8, char8);
+uchar8 __ovld __cnfn bitselect(uchar8, uchar8, uchar8);
+char16 __ovld __cnfn bitselect(char16, char16, char16);
+uchar16 __ovld __cnfn bitselect(uchar16, uchar16, uchar16);
+short __ovld __cnfn bitselect(short, short, short);
+ushort __ovld __cnfn bitselect(ushort, ushort, ushort);
+short2 __ovld __cnfn bitselect(short2, short2, short2);
+ushort2 __ovld __cnfn bitselect(ushort2, ushort2, ushort2);
+short3 __ovld __cnfn bitselect(short3, short3, short3);
+ushort3 __ovld __cnfn bitselect(ushort3, ushort3, ushort3);
+short4 __ovld __cnfn bitselect(short4, short4, short4);
+ushort4 __ovld __cnfn bitselect(ushort4, ushort4, ushort4);
+short8 __ovld __cnfn bitselect(short8, short8, short8);
+ushort8 __ovld __cnfn bitselect(ushort8, ushort8, ushort8);
+short16 __ovld __cnfn bitselect(short16, short16, short16);
+ushort16 __ovld __cnfn bitselect(ushort16, ushort16, ushort16);
+int __ovld __cnfn bitselect(int, int, int);
+uint __ovld __cnfn bitselect(uint, uint, uint);
+int2 __ovld __cnfn bitselect(int2, int2, int2);
+uint2 __ovld __cnfn bitselect(uint2, uint2, uint2);
+int3 __ovld __cnfn bitselect(int3, int3, int3);
+uint3 __ovld __cnfn bitselect(uint3, uint3, uint3);
+int4 __ovld __cnfn bitselect(int4, int4, int4);
+uint4 __ovld __cnfn bitselect(uint4, uint4, uint4);
+int8 __ovld __cnfn bitselect(int8, int8, int8);
+uint8 __ovld __cnfn bitselect(uint8, uint8, uint8);
+int16 __ovld __cnfn bitselect(int16, int16, int16);
+uint16 __ovld __cnfn bitselect(uint16, uint16, uint16);
+long __ovld __cnfn bitselect(long, long, long);
+ulong __ovld __cnfn bitselect(ulong, ulong, ulong);
+long2 __ovld __cnfn bitselect(long2, long2, long2);
+ulong2 __ovld __cnfn bitselect(ulong2, ulong2, ulong2);
+long3 __ovld __cnfn bitselect(long3, long3, long3);
+ulong3 __ovld __cnfn bitselect(ulong3, ulong3, ulong3);
+long4 __ovld __cnfn bitselect(long4, long4, long4);
+ulong4 __ovld __cnfn bitselect(ulong4, ulong4, ulong4);
+long8 __ovld __cnfn bitselect(long8, long8, long8);
+ulong8 __ovld __cnfn bitselect(ulong8, ulong8, ulong8);
+long16 __ovld __cnfn bitselect(long16, long16, long16);
+ulong16 __ovld __cnfn bitselect(ulong16, ulong16, ulong16);
+float __ovld __cnfn bitselect(float, float, float);
+float2 __ovld __cnfn bitselect(float2, float2, float2);
+float3 __ovld __cnfn bitselect(float3, float3, float3);
+float4 __ovld __cnfn bitselect(float4, float4, float4);
+float8 __ovld __cnfn bitselect(float8, float8, float8);
+float16 __ovld __cnfn bitselect(float16, float16, float16);
+#ifdef cl_khr_fp64
+double __ovld __cnfn bitselect(double, double, double);
+double2 __ovld __cnfn bitselect(double2, double2, double2);
+double3 __ovld __cnfn bitselect(double3, double3, double3);
+double4 __ovld __cnfn bitselect(double4, double4, double4);
+double8 __ovld __cnfn bitselect(double8, double8, double8);
+double16 __ovld __cnfn bitselect(double16, double16, double16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn bitselect(half, half, half);
+half2 __ovld __cnfn bitselect(half2, half2, half2);
+half3 __ovld __cnfn bitselect(half3, half3, half3);
+half4 __ovld __cnfn bitselect(half4, half4, half4);
+half8 __ovld __cnfn bitselect(half8, half8, half8);
+half16 __ovld __cnfn bitselect(half16, half16, half16);
+#endif //cl_khr_fp16
+
+/**
+ * For each component of a vector type,
+ * result[i] = if MSB of c[i] is set ? b[i] : a[i].
+ * For a scalar type, result = c ? b : a.
+ * b and a must have the same type.
+ * c must have the same number of elements and bits as a.
+ */
+char __ovld __cnfn select(char, char, char);
+uchar __ovld __cnfn select(uchar, uchar, char);
+char2 __ovld __cnfn select(char2, char2, char2);
+uchar2 __ovld __cnfn select(uchar2, uchar2, char2);
+char3 __ovld __cnfn select(char3, char3, char3);
+uchar3 __ovld __cnfn select(uchar3, uchar3, char3);
+char4 __ovld __cnfn select(char4, char4, char4);
+uchar4 __ovld __cnfn select(uchar4, uchar4, char4);
+char8 __ovld __cnfn select(char8, char8, char8);
+uchar8 __ovld __cnfn select(uchar8, uchar8, char8);
+char16 __ovld __cnfn select(char16, char16, char16);
+uchar16 __ovld __cnfn select(uchar16, uchar16, char16);
+
+short __ovld __cnfn select(short, short, short);
+ushort __ovld __cnfn select(ushort, ushort, short);
+short2 __ovld __cnfn select(short2, short2, short2);
+ushort2 __ovld __cnfn select(ushort2, ushort2, short2);
+short3 __ovld __cnfn select(short3, short3, short3);
+ushort3 __ovld __cnfn select(ushort3, ushort3, short3);
+short4 __ovld __cnfn select(short4, short4, short4);
+ushort4 __ovld __cnfn select(ushort4, ushort4, short4);
+short8 __ovld __cnfn select(short8, short8, short8);
+ushort8 __ovld __cnfn select(ushort8, ushort8, short8);
+short16 __ovld __cnfn select(short16, short16, short16);
+ushort16 __ovld __cnfn select(ushort16, ushort16, short16);
+
+int __ovld __cnfn select(int, int, int);
+uint __ovld __cnfn select(uint, uint, int);
+int2 __ovld __cnfn select(int2, int2, int2);
+uint2 __ovld __cnfn select(uint2, uint2, int2);
+int3 __ovld __cnfn select(int3, int3, int3);
+uint3 __ovld __cnfn select(uint3, uint3, int3);
+int4 __ovld __cnfn select(int4, int4, int4);
+uint4 __ovld __cnfn select(uint4, uint4, int4);
+int8 __ovld __cnfn select(int8, int8, int8);
+uint8 __ovld __cnfn select(uint8, uint8, int8);
+int16 __ovld __cnfn select(int16, int16, int16);
+uint16 __ovld __cnfn select(uint16, uint16, int16);
+float __ovld __cnfn select(float, float, int);
+float2 __ovld __cnfn select(float2, float2, int2);
+float3 __ovld __cnfn select(float3, float3, int3);
+float4 __ovld __cnfn select(float4, float4, int4);
+float8 __ovld __cnfn select(float8, float8, int8);
+float16 __ovld __cnfn select(float16, float16, int16);
+
+long __ovld __cnfn select(long, long, long);
+ulong __ovld __cnfn select(ulong, ulong, long);
+long2 __ovld __cnfn select(long2, long2, long2);
+ulong2 __ovld __cnfn select(ulong2, ulong2, long2);
+long3 __ovld __cnfn select(long3, long3, long3);
+ulong3 __ovld __cnfn select(ulong3, ulong3, long3);
+long4 __ovld __cnfn select(long4, long4, long4);
+ulong4 __ovld __cnfn select(ulong4, ulong4, long4);
+long8 __ovld __cnfn select(long8, long8, long8);
+ulong8 __ovld __cnfn select(ulong8, ulong8, long8);
+long16 __ovld __cnfn select(long16, long16, long16);
+ulong16 __ovld __cnfn select(ulong16, ulong16, long16);
+
+char __ovld __cnfn select(char, char, uchar);
+uchar __ovld __cnfn select(uchar, uchar, uchar);
+char2 __ovld __cnfn select(char2, char2, uchar2);
+uchar2 __ovld __cnfn select(uchar2, uchar2, uchar2);
+char3 __ovld __cnfn select(char3, char3, uchar3);
+uchar3 __ovld __cnfn select(uchar3, uchar3, uchar3);
+char4 __ovld __cnfn select(char4, char4, uchar4);
+uchar4 __ovld __cnfn select(uchar4, uchar4, uchar4);
+char8 __ovld __cnfn select(char8, char8, uchar8);
+uchar8 __ovld __cnfn select(uchar8, uchar8, uchar8);
+char16 __ovld __cnfn select(char16, char16, uchar16);
+uchar16 __ovld __cnfn select(uchar16, uchar16, uchar16);
+
+short __ovld __cnfn select(short, short, ushort);
+ushort __ovld __cnfn select(ushort, ushort, ushort);
+short2 __ovld __cnfn select(short2, short2, ushort2);
+ushort2 __ovld __cnfn select(ushort2, ushort2, ushort2);
+short3 __ovld __cnfn select(short3, short3, ushort3);
+ushort3 __ovld __cnfn select(ushort3, ushort3, ushort3);
+short4 __ovld __cnfn select(short4, short4, ushort4);
+ushort4 __ovld __cnfn select(ushort4, ushort4, ushort4);
+short8 __ovld __cnfn select(short8, short8, ushort8);
+ushort8 __ovld __cnfn select(ushort8, ushort8, ushort8);
+short16 __ovld __cnfn select(short16, short16, ushort16);
+ushort16 __ovld __cnfn select(ushort16, ushort16, ushort16);
+
+int __ovld __cnfn select(int, int, uint);
+uint __ovld __cnfn select(uint, uint, uint);
+int2 __ovld __cnfn select(int2, int2, uint2);
+uint2 __ovld __cnfn select(uint2, uint2, uint2);
+int3 __ovld __cnfn select(int3, int3, uint3);
+uint3 __ovld __cnfn select(uint3, uint3, uint3);
+int4 __ovld __cnfn select(int4, int4, uint4);
+uint4 __ovld __cnfn select(uint4, uint4, uint4);
+int8 __ovld __cnfn select(int8, int8, uint8);
+uint8 __ovld __cnfn select(uint8, uint8, uint8);
+int16 __ovld __cnfn select(int16, int16, uint16);
+uint16 __ovld __cnfn select(uint16, uint16, uint16);
+float __ovld __cnfn select(float, float, uint);
+float2 __ovld __cnfn select(float2, float2, uint2);
+float3 __ovld __cnfn select(float3, float3, uint3);
+float4 __ovld __cnfn select(float4, float4, uint4);
+float8 __ovld __cnfn select(float8, float8, uint8);
+float16 __ovld __cnfn select(float16, float16, uint16);
+
+long __ovld __cnfn select(long, long, ulong);
+ulong __ovld __cnfn select(ulong, ulong, ulong);
+long2 __ovld __cnfn select(long2, long2, ulong2);
+ulong2 __ovld __cnfn select(ulong2, ulong2, ulong2);
+long3 __ovld __cnfn select(long3, long3, ulong3);
+ulong3 __ovld __cnfn select(ulong3, ulong3, ulong3);
+long4 __ovld __cnfn select(long4, long4, ulong4);
+ulong4 __ovld __cnfn select(ulong4, ulong4, ulong4);
+long8 __ovld __cnfn select(long8, long8, ulong8);
+ulong8 __ovld __cnfn select(ulong8, ulong8, ulong8);
+long16 __ovld __cnfn select(long16, long16, ulong16);
+ulong16 __ovld __cnfn select(ulong16, ulong16, ulong16);
+
+#ifdef cl_khr_fp64
+double __ovld __cnfn select(double, double, long);
+double2 __ovld __cnfn select(double2, double2, long2);
+double3 __ovld __cnfn select(double3, double3, long3);
+double4 __ovld __cnfn select(double4, double4, long4);
+double8 __ovld __cnfn select(double8, double8, long8);
+double16 __ovld __cnfn select(double16, double16, long16);
+double __ovld __cnfn select(double, double, ulong);
+double2 __ovld __cnfn select(double2, double2, ulong2);
+double3 __ovld __cnfn select(double3, double3, ulong3);
+double4 __ovld __cnfn select(double4, double4, ulong4);
+double8 __ovld __cnfn select(double8, double8, ulong8);
+double16 __ovld __cnfn select(double16, double16, ulong16);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+half __ovld __cnfn select(half, half, short);
+half2 __ovld __cnfn select(half2, half2, short2);
+half3 __ovld __cnfn select(half3, half3, short3);
+half4 __ovld __cnfn select(half4, half4, short4);
+half8 __ovld __cnfn select(half8, half8, short8);
+half16 __ovld __cnfn select(half16, half16, short16);
+half __ovld __cnfn select(half, half, ushort);
+half2 __ovld __cnfn select(half2, half2, ushort2);
+half3 __ovld __cnfn select(half3, half3, ushort3);
+half4 __ovld __cnfn select(half4, half4, ushort4);
+half8 __ovld __cnfn select(half8, half8, ushort8);
+half16 __ovld __cnfn select(half16, half16, ushort16);
+#endif //cl_khr_fp16
+
+// OpenCL v1.1 s6.11.7, v1.2 s6.12.7, v2.0 s6.13.7 - Vector Data Load and Store Functions
+// OpenCL extensions v1.1 s9.6.6, v1.2 s9.5.6, v2.0 s9.4.6 - Vector Data Load and Store Functions for Half Type
+/**
+ * Use generic type gentype to indicate the built-in data types
+ * char, uchar, short, ushort, int, uint, long, ulong, float,
+ * double or half.
+ *
+ * vloadn return sizeof (gentypen) bytes of data read from address (p + (offset * n)).
+ *
+ * vstoren write sizeof (gentypen) bytes given by data to address (p + (offset * n)).
+ *
+ * The address computed as (p + (offset * n)) must be
+ * 8-bit aligned if gentype is char, uchar;
+ * 16-bit aligned if gentype is short, ushort, half;
+ * 32-bit aligned if gentype is int, uint, float;
+ * 64-bit aligned if gentype is long, ulong, double.
+ */
+
+char2 __ovld __purefn vload2(size_t, const __constant char *);
+uchar2 __ovld __purefn vload2(size_t, const __constant uchar *);
+short2 __ovld __purefn vload2(size_t, const __constant short *);
+ushort2 __ovld __purefn vload2(size_t, const __constant ushort *);
+int2 __ovld __purefn vload2(size_t, const __constant int *);
+uint2 __ovld __purefn vload2(size_t, const __constant uint *);
+long2 __ovld __purefn vload2(size_t, const __constant long *);
+ulong2 __ovld __purefn vload2(size_t, const __constant ulong *);
+float2 __ovld __purefn vload2(size_t, const __constant float *);
+char3 __ovld __purefn vload3(size_t, const __constant char *);
+uchar3 __ovld __purefn vload3(size_t, const __constant uchar *);
+short3 __ovld __purefn vload3(size_t, const __constant short *);
+ushort3 __ovld __purefn vload3(size_t, const __constant ushort *);
+int3 __ovld __purefn vload3(size_t, const __constant int *);
+uint3 __ovld __purefn vload3(size_t, const __constant uint *);
+long3 __ovld __purefn vload3(size_t, const __constant long *);
+ulong3 __ovld __purefn vload3(size_t, const __constant ulong *);
+float3 __ovld __purefn vload3(size_t, const __constant float *);
+char4 __ovld __purefn vload4(size_t, const __constant char *);
+uchar4 __ovld __purefn vload4(size_t, const __constant uchar *);
+short4 __ovld __purefn vload4(size_t, const __constant short *);
+ushort4 __ovld __purefn vload4(size_t, const __constant ushort *);
+int4 __ovld __purefn vload4(size_t, const __constant int *);
+uint4 __ovld __purefn vload4(size_t, const __constant uint *);
+long4 __ovld __purefn vload4(size_t, const __constant long *);
+ulong4 __ovld __purefn vload4(size_t, const __constant ulong *);
+float4 __ovld __purefn vload4(size_t, const __constant float *);
+char8 __ovld __purefn vload8(size_t, const __constant char *);
+uchar8 __ovld __purefn vload8(size_t, const __constant uchar *);
+short8 __ovld __purefn vload8(size_t, const __constant short *);
+ushort8 __ovld __purefn vload8(size_t, const __constant ushort *);
+int8 __ovld __purefn vload8(size_t, const __constant int *);
+uint8 __ovld __purefn vload8(size_t, const __constant uint *);
+long8 __ovld __purefn vload8(size_t, const __constant long *);
+ulong8 __ovld __purefn vload8(size_t, const __constant ulong *);
+float8 __ovld __purefn vload8(size_t, const __constant float *);
+char16 __ovld __purefn vload16(size_t, const __constant char *);
+uchar16 __ovld __purefn vload16(size_t, const __constant uchar *);
+short16 __ovld __purefn vload16(size_t, const __constant short *);
+ushort16 __ovld __purefn vload16(size_t, const __constant ushort *);
+int16 __ovld __purefn vload16(size_t, const __constant int *);
+uint16 __ovld __purefn vload16(size_t, const __constant uint *);
+long16 __ovld __purefn vload16(size_t, const __constant long *);
+ulong16 __ovld __purefn vload16(size_t, const __constant ulong *);
+float16 __ovld __purefn vload16(size_t, const __constant float *);
+#ifdef cl_khr_fp64
+double2 __ovld __purefn vload2(size_t, const __constant double *);
+double3 __ovld __purefn vload3(size_t, const __constant double *);
+double4 __ovld __purefn vload4(size_t, const __constant double *);
+double8 __ovld __purefn vload8(size_t, const __constant double *);
+double16 __ovld __purefn vload16(size_t, const __constant double *);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+half2 __ovld __purefn vload2(size_t, const __constant half *);
+half3 __ovld __purefn vload3(size_t, const __constant half *);
+half4 __ovld __purefn vload4(size_t, const __constant half *);
+half8 __ovld __purefn vload8(size_t, const __constant half *);
+half16 __ovld __purefn vload16(size_t, const __constant half *);
+#endif //cl_khr_fp16
+
+#if defined(__opencl_c_generic_address_space)
+char2 __ovld __purefn vload2(size_t, const char *);
+uchar2 __ovld __purefn vload2(size_t, const uchar *);
+short2 __ovld __purefn vload2(size_t, const short *);
+ushort2 __ovld __purefn vload2(size_t, const ushort *);
+int2 __ovld __purefn vload2(size_t, const int *);
+uint2 __ovld __purefn vload2(size_t, const uint *);
+long2 __ovld __purefn vload2(size_t, const long *);
+ulong2 __ovld __purefn vload2(size_t, const ulong *);
+float2 __ovld __purefn vload2(size_t, const float *);
+char3 __ovld __purefn vload3(size_t, const char *);
+uchar3 __ovld __purefn vload3(size_t, const uchar *);
+short3 __ovld __purefn vload3(size_t, const short *);
+ushort3 __ovld __purefn vload3(size_t, const ushort *);
+int3 __ovld __purefn vload3(size_t, const int *);
+uint3 __ovld __purefn vload3(size_t, const uint *);
+long3 __ovld __purefn vload3(size_t, const long *);
+ulong3 __ovld __purefn vload3(size_t, const ulong *);
+float3 __ovld __purefn vload3(size_t, const float *);
+char4 __ovld __purefn vload4(size_t, const char *);
+uchar4 __ovld __purefn vload4(size_t, const uchar *);
+short4 __ovld __purefn vload4(size_t, const short *);
+ushort4 __ovld __purefn vload4(size_t, const ushort *);
+int4 __ovld __purefn vload4(size_t, const int *);
+uint4 __ovld __purefn vload4(size_t, const uint *);
+long4 __ovld __purefn vload4(size_t, const long *);
+ulong4 __ovld __purefn vload4(size_t, const ulong *);
+float4 __ovld __purefn vload4(size_t, const float *);
+char8 __ovld __purefn vload8(size_t, const char *);
+uchar8 __ovld __purefn vload8(size_t, const uchar *);
+short8 __ovld __purefn vload8(size_t, const short *);
+ushort8 __ovld __purefn vload8(size_t, const ushort *);
+int8 __ovld __purefn vload8(size_t, const int *);
+uint8 __ovld __purefn vload8(size_t, const uint *);
+long8 __ovld __purefn vload8(size_t, const long *);
+ulong8 __ovld __purefn vload8(size_t, const ulong *);
+float8 __ovld __purefn vload8(size_t, const float *);
+char16 __ovld __purefn vload16(size_t, const char *);
+uchar16 __ovld __purefn vload16(size_t, const uchar *);
+short16 __ovld __purefn vload16(size_t, const short *);
+ushort16 __ovld __purefn vload16(size_t, const ushort *);
+int16 __ovld __purefn vload16(size_t, const int *);
+uint16 __ovld __purefn vload16(size_t, const uint *);
+long16 __ovld __purefn vload16(size_t, const long *);
+ulong16 __ovld __purefn vload16(size_t, const ulong *);
+float16 __ovld __purefn vload16(size_t, const float *);
+
+#ifdef cl_khr_fp64
+double2 __ovld __purefn vload2(size_t, const double *);
+double3 __ovld __purefn vload3(size_t, const double *);
+double4 __ovld __purefn vload4(size_t, const double *);
+double8 __ovld __purefn vload8(size_t, const double *);
+double16 __ovld __purefn vload16(size_t, const double *);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+half2 __ovld __purefn vload2(size_t, const half *);
+half3 __ovld __purefn vload3(size_t, const half *);
+half4 __ovld __purefn vload4(size_t, const half *);
+half8 __ovld __purefn vload8(size_t, const half *);
+half16 __ovld __purefn vload16(size_t, const half *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+char2 __ovld __purefn vload2(size_t, const __global char *);
+uchar2 __ovld __purefn vload2(size_t, const __global uchar *);
+short2 __ovld __purefn vload2(size_t, const __global short *);
+ushort2 __ovld __purefn vload2(size_t, const __global ushort *);
+int2 __ovld __purefn vload2(size_t, const __global int *);
+uint2 __ovld __purefn vload2(size_t, const __global uint *);
+long2 __ovld __purefn vload2(size_t, const __global long *);
+ulong2 __ovld __purefn vload2(size_t, const __global ulong *);
+float2 __ovld __purefn vload2(size_t, const __global float *);
+char3 __ovld __purefn vload3(size_t, const __global char *);
+uchar3 __ovld __purefn vload3(size_t, const __global uchar *);
+short3 __ovld __purefn vload3(size_t, const __global short *);
+ushort3 __ovld __purefn vload3(size_t, const __global ushort *);
+int3 __ovld __purefn vload3(size_t, const __global int *);
+uint3 __ovld __purefn vload3(size_t, const __global uint *);
+long3 __ovld __purefn vload3(size_t, const __global long *);
+ulong3 __ovld __purefn vload3(size_t, const __global ulong *);
+float3 __ovld __purefn vload3(size_t, const __global float *);
+char4 __ovld __purefn vload4(size_t, const __global char *);
+uchar4 __ovld __purefn vload4(size_t, const __global uchar *);
+short4 __ovld __purefn vload4(size_t, const __global short *);
+ushort4 __ovld __purefn vload4(size_t, const __global ushort *);
+int4 __ovld __purefn vload4(size_t, const __global int *);
+uint4 __ovld __purefn vload4(size_t, const __global uint *);
+long4 __ovld __purefn vload4(size_t, const __global long *);
+ulong4 __ovld __purefn vload4(size_t, const __global ulong *);
+float4 __ovld __purefn vload4(size_t, const __global float *);
+char8 __ovld __purefn vload8(size_t, const __global char *);
+uchar8 __ovld __purefn vload8(size_t, const __global uchar *);
+short8 __ovld __purefn vload8(size_t, const __global short *);
+ushort8 __ovld __purefn vload8(size_t, const __global ushort *);
+int8 __ovld __purefn vload8(size_t, const __global int *);
+uint8 __ovld __purefn vload8(size_t, const __global uint *);
+long8 __ovld __purefn vload8(size_t, const __global long *);
+ulong8 __ovld __purefn vload8(size_t, const __global ulong *);
+float8 __ovld __purefn vload8(size_t, const __global float *);
+char16 __ovld __purefn vload16(size_t, const __global char *);
+uchar16 __ovld __purefn vload16(size_t, const __global uchar *);
+short16 __ovld __purefn vload16(size_t, const __global short *);
+ushort16 __ovld __purefn vload16(size_t, const __global ushort *);
+int16 __ovld __purefn vload16(size_t, const __global int *);
+uint16 __ovld __purefn vload16(size_t, const __global uint *);
+long16 __ovld __purefn vload16(size_t, const __global long *);
+ulong16 __ovld __purefn vload16(size_t, const __global ulong *);
+float16 __ovld __purefn vload16(size_t, const __global float *);
+char2 __ovld __purefn vload2(size_t, const __local char *);
+uchar2 __ovld __purefn vload2(size_t, const __local uchar *);
+short2 __ovld __purefn vload2(size_t, const __local short *);
+ushort2 __ovld __purefn vload2(size_t, const __local ushort *);
+int2 __ovld __purefn vload2(size_t, const __local int *);
+uint2 __ovld __purefn vload2(size_t, const __local uint *);
+long2 __ovld __purefn vload2(size_t, const __local long *);
+ulong2 __ovld __purefn vload2(size_t, const __local ulong *);
+float2 __ovld __purefn vload2(size_t, const __local float *);
+char3 __ovld __purefn vload3(size_t, const __local char *);
+uchar3 __ovld __purefn vload3(size_t, const __local uchar *);
+short3 __ovld __purefn vload3(size_t, const __local short *);
+ushort3 __ovld __purefn vload3(size_t, const __local ushort *);
+int3 __ovld __purefn vload3(size_t, const __local int *);
+uint3 __ovld __purefn vload3(size_t, const __local uint *);
+long3 __ovld __purefn vload3(size_t, const __local long *);
+ulong3 __ovld __purefn vload3(size_t, const __local ulong *);
+float3 __ovld __purefn vload3(size_t, const __local float *);
+char4 __ovld __purefn vload4(size_t, const __local char *);
+uchar4 __ovld __purefn vload4(size_t, const __local uchar *);
+short4 __ovld __purefn vload4(size_t, const __local short *);
+ushort4 __ovld __purefn vload4(size_t, const __local ushort *);
+int4 __ovld __purefn vload4(size_t, const __local int *);
+uint4 __ovld __purefn vload4(size_t, const __local uint *);
+long4 __ovld __purefn vload4(size_t, const __local long *);
+ulong4 __ovld __purefn vload4(size_t, const __local ulong *);
+float4 __ovld __purefn vload4(size_t, const __local float *);
+char8 __ovld __purefn vload8(size_t, const __local char *);
+uchar8 __ovld __purefn vload8(size_t, const __local uchar *);
+short8 __ovld __purefn vload8(size_t, const __local short *);
+ushort8 __ovld __purefn vload8(size_t, const __local ushort *);
+int8 __ovld __purefn vload8(size_t, const __local int *);
+uint8 __ovld __purefn vload8(size_t, const __local uint *);
+long8 __ovld __purefn vload8(size_t, const __local long *);
+ulong8 __ovld __purefn vload8(size_t, const __local ulong *);
+float8 __ovld __purefn vload8(size_t, const __local float *);
+char16 __ovld __purefn vload16(size_t, const __local char *);
+uchar16 __ovld __purefn vload16(size_t, const __local uchar *);
+short16 __ovld __purefn vload16(size_t, const __local short *);
+ushort16 __ovld __purefn vload16(size_t, const __local ushort *);
+int16 __ovld __purefn vload16(size_t, const __local int *);
+uint16 __ovld __purefn vload16(size_t, const __local uint *);
+long16 __ovld __purefn vload16(size_t, const __local long *);
+ulong16 __ovld __purefn vload16(size_t, const __local ulong *);
+float16 __ovld __purefn vload16(size_t, const __local float *);
+char2 __ovld __purefn vload2(size_t, const __private char *);
+uchar2 __ovld __purefn vload2(size_t, const __private uchar *);
+short2 __ovld __purefn vload2(size_t, const __private short *);
+ushort2 __ovld __purefn vload2(size_t, const __private ushort *);
+int2 __ovld __purefn vload2(size_t, const __private int *);
+uint2 __ovld __purefn vload2(size_t, const __private uint *);
+long2 __ovld __purefn vload2(size_t, const __private long *);
+ulong2 __ovld __purefn vload2(size_t, const __private ulong *);
+float2 __ovld __purefn vload2(size_t, const __private float *);
+char3 __ovld __purefn vload3(size_t, const __private char *);
+uchar3 __ovld __purefn vload3(size_t, const __private uchar *);
+short3 __ovld __purefn vload3(size_t, const __private short *);
+ushort3 __ovld __purefn vload3(size_t, const __private ushort *);
+int3 __ovld __purefn vload3(size_t, const __private int *);
+uint3 __ovld __purefn vload3(size_t, const __private uint *);
+long3 __ovld __purefn vload3(size_t, const __private long *);
+ulong3 __ovld __purefn vload3(size_t, const __private ulong *);
+float3 __ovld __purefn vload3(size_t, const __private float *);
+char4 __ovld __purefn vload4(size_t, const __private char *);
+uchar4 __ovld __purefn vload4(size_t, const __private uchar *);
+short4 __ovld __purefn vload4(size_t, const __private short *);
+ushort4 __ovld __purefn vload4(size_t, const __private ushort *);
+int4 __ovld __purefn vload4(size_t, const __private int *);
+uint4 __ovld __purefn vload4(size_t, const __private uint *);
+long4 __ovld __purefn vload4(size_t, const __private long *);
+ulong4 __ovld __purefn vload4(size_t, const __private ulong *);
+float4 __ovld __purefn vload4(size_t, const __private float *);
+char8 __ovld __purefn vload8(size_t, const __private char *);
+uchar8 __ovld __purefn vload8(size_t, const __private uchar *);
+short8 __ovld __purefn vload8(size_t, const __private short *);
+ushort8 __ovld __purefn vload8(size_t, const __private ushort *);
+int8 __ovld __purefn vload8(size_t, const __private int *);
+uint8 __ovld __purefn vload8(size_t, const __private uint *);
+long8 __ovld __purefn vload8(size_t, const __private long *);
+ulong8 __ovld __purefn vload8(size_t, const __private ulong *);
+float8 __ovld __purefn vload8(size_t, const __private float *);
+char16 __ovld __purefn vload16(size_t, const __private char *);
+uchar16 __ovld __purefn vload16(size_t, const __private uchar *);
+short16 __ovld __purefn vload16(size_t, const __private short *);
+ushort16 __ovld __purefn vload16(size_t, const __private ushort *);
+int16 __ovld __purefn vload16(size_t, const __private int *);
+uint16 __ovld __purefn vload16(size_t, const __private uint *);
+long16 __ovld __purefn vload16(size_t, const __private long *);
+ulong16 __ovld __purefn vload16(size_t, const __private ulong *);
+float16 __ovld __purefn vload16(size_t, const __private float *);
+
+#ifdef cl_khr_fp64
+double2 __ovld __purefn vload2(size_t, const __global double *);
+double3 __ovld __purefn vload3(size_t, const __global double *);
+double4 __ovld __purefn vload4(size_t, const __global double *);
+double8 __ovld __purefn vload8(size_t, const __global double *);
+double16 __ovld __purefn vload16(size_t, const __global double *);
+double2 __ovld __purefn vload2(size_t, const __local double *);
+double3 __ovld __purefn vload3(size_t, const __local double *);
+double4 __ovld __purefn vload4(size_t, const __local double *);
+double8 __ovld __purefn vload8(size_t, const __local double *);
+double16 __ovld __purefn vload16(size_t, const __local double *);
+double2 __ovld __purefn vload2(size_t, const __private double *);
+double3 __ovld __purefn vload3(size_t, const __private double *);
+double4 __ovld __purefn vload4(size_t, const __private double *);
+double8 __ovld __purefn vload8(size_t, const __private double *);
+double16 __ovld __purefn vload16(size_t, const __private double *);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+half2 __ovld __purefn vload2(size_t, const __global half *);
+half3 __ovld __purefn vload3(size_t, const __global half *);
+half4 __ovld __purefn vload4(size_t, const __global half *);
+half8 __ovld __purefn vload8(size_t, const __global half *);
+half16 __ovld __purefn vload16(size_t, const __global half *);
+half2 __ovld __purefn vload2(size_t, const __local half *);
+half3 __ovld __purefn vload3(size_t, const __local half *);
+half4 __ovld __purefn vload4(size_t, const __local half *);
+half8 __ovld __purefn vload8(size_t, const __local half *);
+half16 __ovld __purefn vload16(size_t, const __local half *);
+half2 __ovld __purefn vload2(size_t, const __private half *);
+half3 __ovld __purefn vload3(size_t, const __private half *);
+half4 __ovld __purefn vload4(size_t, const __private half *);
+half8 __ovld __purefn vload8(size_t, const __private half *);
+half16 __ovld __purefn vload16(size_t, const __private half *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+#if defined(__opencl_c_generic_address_space)
+void __ovld vstore2(char2, size_t, char *);
+void __ovld vstore2(uchar2, size_t, uchar *);
+void __ovld vstore2(short2, size_t, short *);
+void __ovld vstore2(ushort2, size_t, ushort *);
+void __ovld vstore2(int2, size_t, int *);
+void __ovld vstore2(uint2, size_t, uint *);
+void __ovld vstore2(long2, size_t, long *);
+void __ovld vstore2(ulong2, size_t, ulong *);
+void __ovld vstore2(float2, size_t, float *);
+void __ovld vstore3(char3, size_t, char *);
+void __ovld vstore3(uchar3, size_t, uchar *);
+void __ovld vstore3(short3, size_t, short *);
+void __ovld vstore3(ushort3, size_t, ushort *);
+void __ovld vstore3(int3, size_t, int *);
+void __ovld vstore3(uint3, size_t, uint *);
+void __ovld vstore3(long3, size_t, long *);
+void __ovld vstore3(ulong3, size_t, ulong *);
+void __ovld vstore3(float3, size_t, float *);
+void __ovld vstore4(char4, size_t, char *);
+void __ovld vstore4(uchar4, size_t, uchar *);
+void __ovld vstore4(short4, size_t, short *);
+void __ovld vstore4(ushort4, size_t, ushort *);
+void __ovld vstore4(int4, size_t, int *);
+void __ovld vstore4(uint4, size_t, uint *);
+void __ovld vstore4(long4, size_t, long *);
+void __ovld vstore4(ulong4, size_t, ulong *);
+void __ovld vstore4(float4, size_t, float *);
+void __ovld vstore8(char8, size_t, char *);
+void __ovld vstore8(uchar8, size_t, uchar *);
+void __ovld vstore8(short8, size_t, short *);
+void __ovld vstore8(ushort8, size_t, ushort *);
+void __ovld vstore8(int8, size_t, int *);
+void __ovld vstore8(uint8, size_t, uint *);
+void __ovld vstore8(long8, size_t, long *);
+void __ovld vstore8(ulong8, size_t, ulong *);
+void __ovld vstore8(float8, size_t, float *);
+void __ovld vstore16(char16, size_t, char *);
+void __ovld vstore16(uchar16, size_t, uchar *);
+void __ovld vstore16(short16, size_t, short *);
+void __ovld vstore16(ushort16, size_t, ushort *);
+void __ovld vstore16(int16, size_t, int *);
+void __ovld vstore16(uint16, size_t, uint *);
+void __ovld vstore16(long16, size_t, long *);
+void __ovld vstore16(ulong16, size_t, ulong *);
+void __ovld vstore16(float16, size_t, float *);
+#ifdef cl_khr_fp64
+void __ovld vstore2(double2, size_t, double *);
+void __ovld vstore3(double3, size_t, double *);
+void __ovld vstore4(double4, size_t, double *);
+void __ovld vstore8(double8, size_t, double *);
+void __ovld vstore16(double16, size_t, double *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+void __ovld vstore2(half2, size_t, half *);
+void __ovld vstore3(half3, size_t, half *);
+void __ovld vstore4(half4, size_t, half *);
+void __ovld vstore8(half8, size_t, half *);
+void __ovld vstore16(half16, size_t, half *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+void __ovld vstore2(char2, size_t, __global char *);
+void __ovld vstore2(uchar2, size_t, __global uchar *);
+void __ovld vstore2(short2, size_t, __global short *);
+void __ovld vstore2(ushort2, size_t, __global ushort *);
+void __ovld vstore2(int2, size_t, __global int *);
+void __ovld vstore2(uint2, size_t, __global uint *);
+void __ovld vstore2(long2, size_t, __global long *);
+void __ovld vstore2(ulong2, size_t, __global ulong *);
+void __ovld vstore2(float2, size_t, __global float *);
+void __ovld vstore3(char3, size_t, __global char *);
+void __ovld vstore3(uchar3, size_t, __global uchar *);
+void __ovld vstore3(short3, size_t, __global short *);
+void __ovld vstore3(ushort3, size_t, __global ushort *);
+void __ovld vstore3(int3, size_t, __global int *);
+void __ovld vstore3(uint3, size_t, __global uint *);
+void __ovld vstore3(long3, size_t, __global long *);
+void __ovld vstore3(ulong3, size_t, __global ulong *);
+void __ovld vstore3(float3, size_t, __global float *);
+void __ovld vstore4(char4, size_t, __global char *);
+void __ovld vstore4(uchar4, size_t, __global uchar *);
+void __ovld vstore4(short4, size_t, __global short *);
+void __ovld vstore4(ushort4, size_t, __global ushort *);
+void __ovld vstore4(int4, size_t, __global int *);
+void __ovld vstore4(uint4, size_t, __global uint *);
+void __ovld vstore4(long4, size_t, __global long *);
+void __ovld vstore4(ulong4, size_t, __global ulong *);
+void __ovld vstore4(float4, size_t, __global float *);
+void __ovld vstore8(char8, size_t, __global char *);
+void __ovld vstore8(uchar8, size_t, __global uchar *);
+void __ovld vstore8(short8, size_t, __global short *);
+void __ovld vstore8(ushort8, size_t, __global ushort *);
+void __ovld vstore8(int8, size_t, __global int *);
+void __ovld vstore8(uint8, size_t, __global uint *);
+void __ovld vstore8(long8, size_t, __global long *);
+void __ovld vstore8(ulong8, size_t, __global ulong *);
+void __ovld vstore8(float8, size_t, __global float *);
+void __ovld vstore16(char16, size_t, __global char *);
+void __ovld vstore16(uchar16, size_t, __global uchar *);
+void __ovld vstore16(short16, size_t, __global short *);
+void __ovld vstore16(ushort16, size_t, __global ushort *);
+void __ovld vstore16(int16, size_t, __global int *);
+void __ovld vstore16(uint16, size_t, __global uint *);
+void __ovld vstore16(long16, size_t, __global long *);
+void __ovld vstore16(ulong16, size_t, __global ulong *);
+void __ovld vstore16(float16, size_t, __global float *);
+void __ovld vstore2(char2, size_t, __local char *);
+void __ovld vstore2(uchar2, size_t, __local uchar *);
+void __ovld vstore2(short2, size_t, __local short *);
+void __ovld vstore2(ushort2, size_t, __local ushort *);
+void __ovld vstore2(int2, size_t, __local int *);
+void __ovld vstore2(uint2, size_t, __local uint *);
+void __ovld vstore2(long2, size_t, __local long *);
+void __ovld vstore2(ulong2, size_t, __local ulong *);
+void __ovld vstore2(float2, size_t, __local float *);
+void __ovld vstore3(char3, size_t, __local char *);
+void __ovld vstore3(uchar3, size_t, __local uchar *);
+void __ovld vstore3(short3, size_t, __local short *);
+void __ovld vstore3(ushort3, size_t, __local ushort *);
+void __ovld vstore3(int3, size_t, __local int *);
+void __ovld vstore3(uint3, size_t, __local uint *);
+void __ovld vstore3(long3, size_t, __local long *);
+void __ovld vstore3(ulong3, size_t, __local ulong *);
+void __ovld vstore3(float3, size_t, __local float *);
+void __ovld vstore4(char4, size_t, __local char *);
+void __ovld vstore4(uchar4, size_t, __local uchar *);
+void __ovld vstore4(short4, size_t, __local short *);
+void __ovld vstore4(ushort4, size_t, __local ushort *);
+void __ovld vstore4(int4, size_t, __local int *);
+void __ovld vstore4(uint4, size_t, __local uint *);
+void __ovld vstore4(long4, size_t, __local long *);
+void __ovld vstore4(ulong4, size_t, __local ulong *);
+void __ovld vstore4(float4, size_t, __local float *);
+void __ovld vstore8(char8, size_t, __local char *);
+void __ovld vstore8(uchar8, size_t, __local uchar *);
+void __ovld vstore8(short8, size_t, __local short *);
+void __ovld vstore8(ushort8, size_t, __local ushort *);
+void __ovld vstore8(int8, size_t, __local int *);
+void __ovld vstore8(uint8, size_t, __local uint *);
+void __ovld vstore8(long8, size_t, __local long *);
+void __ovld vstore8(ulong8, size_t, __local ulong *);
+void __ovld vstore8(float8, size_t, __local float *);
+void __ovld vstore16(char16, size_t, __local char *);
+void __ovld vstore16(uchar16, size_t, __local uchar *);
+void __ovld vstore16(short16, size_t, __local short *);
+void __ovld vstore16(ushort16, size_t, __local ushort *);
+void __ovld vstore16(int16, size_t, __local int *);
+void __ovld vstore16(uint16, size_t, __local uint *);
+void __ovld vstore16(long16, size_t, __local long *);
+void __ovld vstore16(ulong16, size_t, __local ulong *);
+void __ovld vstore16(float16, size_t, __local float *);
+void __ovld vstore2(char2, size_t, __private char *);
+void __ovld vstore2(uchar2, size_t, __private uchar *);
+void __ovld vstore2(short2, size_t, __private short *);
+void __ovld vstore2(ushort2, size_t, __private ushort *);
+void __ovld vstore2(int2, size_t, __private int *);
+void __ovld vstore2(uint2, size_t, __private uint *);
+void __ovld vstore2(long2, size_t, __private long *);
+void __ovld vstore2(ulong2, size_t, __private ulong *);
+void __ovld vstore2(float2, size_t, __private float *);
+void __ovld vstore3(char3, size_t, __private char *);
+void __ovld vstore3(uchar3, size_t, __private uchar *);
+void __ovld vstore3(short3, size_t, __private short *);
+void __ovld vstore3(ushort3, size_t, __private ushort *);
+void __ovld vstore3(int3, size_t, __private int *);
+void __ovld vstore3(uint3, size_t, __private uint *);
+void __ovld vstore3(long3, size_t, __private long *);
+void __ovld vstore3(ulong3, size_t, __private ulong *);
+void __ovld vstore3(float3, size_t, __private float *);
+void __ovld vstore4(char4, size_t, __private char *);
+void __ovld vstore4(uchar4, size_t, __private uchar *);
+void __ovld vstore4(short4, size_t, __private short *);
+void __ovld vstore4(ushort4, size_t, __private ushort *);
+void __ovld vstore4(int4, size_t, __private int *);
+void __ovld vstore4(uint4, size_t, __private uint *);
+void __ovld vstore4(long4, size_t, __private long *);
+void __ovld vstore4(ulong4, size_t, __private ulong *);
+void __ovld vstore4(float4, size_t, __private float *);
+void __ovld vstore8(char8, size_t, __private char *);
+void __ovld vstore8(uchar8, size_t, __private uchar *);
+void __ovld vstore8(short8, size_t, __private short *);
+void __ovld vstore8(ushort8, size_t, __private ushort *);
+void __ovld vstore8(int8, size_t, __private int *);
+void __ovld vstore8(uint8, size_t, __private uint *);
+void __ovld vstore8(long8, size_t, __private long *);
+void __ovld vstore8(ulong8, size_t, __private ulong *);
+void __ovld vstore8(float8, size_t, __private float *);
+void __ovld vstore16(char16, size_t, __private char *);
+void __ovld vstore16(uchar16, size_t, __private uchar *);
+void __ovld vstore16(short16, size_t, __private short *);
+void __ovld vstore16(ushort16, size_t, __private ushort *);
+void __ovld vstore16(int16, size_t, __private int *);
+void __ovld vstore16(uint16, size_t, __private uint *);
+void __ovld vstore16(long16, size_t, __private long *);
+void __ovld vstore16(ulong16, size_t, __private ulong *);
+void __ovld vstore16(float16, size_t, __private float *);
+#ifdef cl_khr_fp64
+void __ovld vstore2(double2, size_t, __global double *);
+void __ovld vstore3(double3, size_t, __global double *);
+void __ovld vstore4(double4, size_t, __global double *);
+void __ovld vstore8(double8, size_t, __global double *);
+void __ovld vstore16(double16, size_t, __global double *);
+void __ovld vstore2(double2, size_t, __local double *);
+void __ovld vstore3(double3, size_t, __local double *);
+void __ovld vstore4(double4, size_t, __local double *);
+void __ovld vstore8(double8, size_t, __local double *);
+void __ovld vstore16(double16, size_t, __local double *);
+void __ovld vstore2(double2, size_t, __private double *);
+void __ovld vstore3(double3, size_t, __private double *);
+void __ovld vstore4(double4, size_t, __private double *);
+void __ovld vstore8(double8, size_t, __private double *);
+void __ovld vstore16(double16, size_t, __private double *);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+void __ovld vstore2(half2, size_t, __global half *);
+void __ovld vstore3(half3, size_t, __global half *);
+void __ovld vstore4(half4, size_t, __global half *);
+void __ovld vstore8(half8, size_t, __global half *);
+void __ovld vstore16(half16, size_t, __global half *);
+void __ovld vstore2(half2, size_t, __local half *);
+void __ovld vstore3(half3, size_t, __local half *);
+void __ovld vstore4(half4, size_t, __local half *);
+void __ovld vstore8(half8, size_t, __local half *);
+void __ovld vstore16(half16, size_t, __local half *);
+void __ovld vstore2(half2, size_t, __private half *);
+void __ovld vstore3(half3, size_t, __private half *);
+void __ovld vstore4(half4, size_t, __private half *);
+void __ovld vstore8(half8, size_t, __private half *);
+void __ovld vstore16(half16, size_t, __private half *);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Read sizeof (half) bytes of data from address
+ * (p + offset). The data read is interpreted as a
+ * half value. The half value is converted to a
+ * float value and the float value is returned.
+ * The read address computed as (p + offset)
+ * must be 16-bit aligned.
+ */
+float __ovld __purefn vload_half(size_t, const __constant half *);
+#if defined(__opencl_c_generic_address_space)
+float __ovld __purefn vload_half(size_t, const half *);
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float __ovld __purefn vload_half(size_t, const __global half *);
+float __ovld __purefn vload_half(size_t, const __local half *);
+float __ovld __purefn vload_half(size_t, const __private half *);
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * Read sizeof (halfn) bytes of data from address
+ * (p + (offset * n)). The data read is interpreted
+ * as a halfn value. The halfn value read is
+ * converted to a floatn value and the floatn
+ * value is returned. The read address computed
+ * as (p + (offset * n)) must be 16-bit aligned.
+ */
+float2 __ovld __purefn vload_half2(size_t, const __constant half *);
+float3 __ovld __purefn vload_half3(size_t, const __constant half *);
+float4 __ovld __purefn vload_half4(size_t, const __constant half *);
+float8 __ovld __purefn vload_half8(size_t, const __constant half *);
+float16 __ovld __purefn vload_half16(size_t, const __constant half *);
+#if defined(__opencl_c_generic_address_space)
+float2 __ovld __purefn vload_half2(size_t, const half *);
+float3 __ovld __purefn vload_half3(size_t, const half *);
+float4 __ovld __purefn vload_half4(size_t, const half *);
+float8 __ovld __purefn vload_half8(size_t, const half *);
+float16 __ovld __purefn vload_half16(size_t, const half *);
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float2 __ovld __purefn vload_half2(size_t, const __global half *);
+float3 __ovld __purefn vload_half3(size_t, const __global half *);
+float4 __ovld __purefn vload_half4(size_t, const __global half *);
+float8 __ovld __purefn vload_half8(size_t, const __global half *);
+float16 __ovld __purefn vload_half16(size_t, const __global half *);
+float2 __ovld __purefn vload_half2(size_t, const __local half *);
+float3 __ovld __purefn vload_half3(size_t, const __local half *);
+float4 __ovld __purefn vload_half4(size_t, const __local half *);
+float8 __ovld __purefn vload_half8(size_t, const __local half *);
+float16 __ovld __purefn vload_half16(size_t, const __local half *);
+float2 __ovld __purefn vload_half2(size_t, const __private half *);
+float3 __ovld __purefn vload_half3(size_t, const __private half *);
+float4 __ovld __purefn vload_half4(size_t, const __private half *);
+float8 __ovld __purefn vload_half8(size_t, const __private half *);
+float16 __ovld __purefn vload_half16(size_t, const __private half *);
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * The float value given by data is first
+ * converted to a half value using the appropriate
+ * rounding mode. The half value is then written
+ * to address computed as (p + offset). The
+ * address computed as (p + offset) must be 16-
+ * bit aligned.
+ * vstore_half use the current rounding mode.
+ * The default current rounding mode is round to
+ * nearest even.
+ */
+#if defined(__opencl_c_generic_address_space)
+void __ovld vstore_half(float, size_t, half *);
+void __ovld vstore_half_rte(float, size_t, half *);
+void __ovld vstore_half_rtz(float, size_t, half *);
+void __ovld vstore_half_rtp(float, size_t, half *);
+void __ovld vstore_half_rtn(float, size_t, half *);
+#ifdef cl_khr_fp64
+void __ovld vstore_half(double, size_t, half *);
+void __ovld vstore_half_rte(double, size_t, half *);
+void __ovld vstore_half_rtz(double, size_t, half *);
+void __ovld vstore_half_rtp(double, size_t, half *);
+void __ovld vstore_half_rtn(double, size_t, half *);
+#endif //cl_khr_fp64
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+void __ovld vstore_half(float, size_t, __global half *);
+void __ovld vstore_half_rte(float, size_t, __global half *);
+void __ovld vstore_half_rtz(float, size_t, __global half *);
+void __ovld vstore_half_rtp(float, size_t, __global half *);
+void __ovld vstore_half_rtn(float, size_t, __global half *);
+void __ovld vstore_half(float, size_t, __local half *);
+void __ovld vstore_half_rte(float, size_t, __local half *);
+void __ovld vstore_half_rtz(float, size_t, __local half *);
+void __ovld vstore_half_rtp(float, size_t, __local half *);
+void __ovld vstore_half_rtn(float, size_t, __local half *);
+void __ovld vstore_half(float, size_t, __private half *);
+void __ovld vstore_half_rte(float, size_t, __private half *);
+void __ovld vstore_half_rtz(float, size_t, __private half *);
+void __ovld vstore_half_rtp(float, size_t, __private half *);
+void __ovld vstore_half_rtn(float, size_t, __private half *);
+#ifdef cl_khr_fp64
+void __ovld vstore_half(double, size_t, __global half *);
+void __ovld vstore_half_rte(double, size_t, __global half *);
+void __ovld vstore_half_rtz(double, size_t, __global half *);
+void __ovld vstore_half_rtp(double, size_t, __global half *);
+void __ovld vstore_half_rtn(double, size_t, __global half *);
+void __ovld vstore_half(double, size_t, __local half *);
+void __ovld vstore_half_rte(double, size_t, __local half *);
+void __ovld vstore_half_rtz(double, size_t, __local half *);
+void __ovld vstore_half_rtp(double, size_t, __local half *);
+void __ovld vstore_half_rtn(double, size_t, __local half *);
+void __ovld vstore_half(double, size_t, __private half *);
+void __ovld vstore_half_rte(double, size_t, __private half *);
+void __ovld vstore_half_rtz(double, size_t, __private half *);
+void __ovld vstore_half_rtp(double, size_t, __private half *);
+void __ovld vstore_half_rtn(double, size_t, __private half *);
+#endif //cl_khr_fp64
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * The floatn value given by data is converted to
+ * a halfn value using the appropriate rounding
+ * mode. The halfn value is then written to
+ * address computed as (p + (offset * n)). The
+ * address computed as (p + (offset * n)) must be
+ * 16-bit aligned.
+ * vstore_halfn uses the current rounding mode.
+ * The default current rounding mode is round to
+ * nearest even.
+ */
+#if defined(__opencl_c_generic_address_space)
+void __ovld vstore_half2(float2, size_t, half *);
+void __ovld vstore_half3(float3, size_t, half *);
+void __ovld vstore_half4(float4, size_t, half *);
+void __ovld vstore_half8(float8, size_t, half *);
+void __ovld vstore_half16(float16, size_t, half *);
+void __ovld vstore_half2_rte(float2, size_t, half *);
+void __ovld vstore_half3_rte(float3, size_t, half *);
+void __ovld vstore_half4_rte(float4, size_t, half *);
+void __ovld vstore_half8_rte(float8, size_t, half *);
+void __ovld vstore_half16_rte(float16, size_t, half *);
+void __ovld vstore_half2_rtz(float2, size_t, half *);
+void __ovld vstore_half3_rtz(float3, size_t, half *);
+void __ovld vstore_half4_rtz(float4, size_t, half *);
+void __ovld vstore_half8_rtz(float8, size_t, half *);
+void __ovld vstore_half16_rtz(float16, size_t, half *);
+void __ovld vstore_half2_rtp(float2, size_t, half *);
+void __ovld vstore_half3_rtp(float3, size_t, half *);
+void __ovld vstore_half4_rtp(float4, size_t, half *);
+void __ovld vstore_half8_rtp(float8, size_t, half *);
+void __ovld vstore_half16_rtp(float16, size_t, half *);
+void __ovld vstore_half2_rtn(float2, size_t, half *);
+void __ovld vstore_half3_rtn(float3, size_t, half *);
+void __ovld vstore_half4_rtn(float4, size_t, half *);
+void __ovld vstore_half8_rtn(float8, size_t, half *);
+void __ovld vstore_half16_rtn(float16, size_t, half *);
+#ifdef cl_khr_fp64
+void __ovld vstore_half2(double2, size_t, half *);
+void __ovld vstore_half3(double3, size_t, half *);
+void __ovld vstore_half4(double4, size_t, half *);
+void __ovld vstore_half8(double8, size_t, half *);
+void __ovld vstore_half16(double16, size_t, half *);
+void __ovld vstore_half2_rte(double2, size_t, half *);
+void __ovld vstore_half3_rte(double3, size_t, half *);
+void __ovld vstore_half4_rte(double4, size_t, half *);
+void __ovld vstore_half8_rte(double8, size_t, half *);
+void __ovld vstore_half16_rte(double16, size_t, half *);
+void __ovld vstore_half2_rtz(double2, size_t, half *);
+void __ovld vstore_half3_rtz(double3, size_t, half *);
+void __ovld vstore_half4_rtz(double4, size_t, half *);
+void __ovld vstore_half8_rtz(double8, size_t, half *);
+void __ovld vstore_half16_rtz(double16, size_t, half *);
+void __ovld vstore_half2_rtp(double2, size_t, half *);
+void __ovld vstore_half3_rtp(double3, size_t, half *);
+void __ovld vstore_half4_rtp(double4, size_t, half *);
+void __ovld vstore_half8_rtp(double8, size_t, half *);
+void __ovld vstore_half16_rtp(double16, size_t, half *);
+void __ovld vstore_half2_rtn(double2, size_t, half *);
+void __ovld vstore_half3_rtn(double3, size_t, half *);
+void __ovld vstore_half4_rtn(double4, size_t, half *);
+void __ovld vstore_half8_rtn(double8, size_t, half *);
+void __ovld vstore_half16_rtn(double16, size_t, half *);
+#endif //cl_khr_fp64
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+void __ovld vstore_half2(float2, size_t, __global half *);
+void __ovld vstore_half3(float3, size_t, __global half *);
+void __ovld vstore_half4(float4, size_t, __global half *);
+void __ovld vstore_half8(float8, size_t, __global half *);
+void __ovld vstore_half16(float16, size_t, __global half *);
+void __ovld vstore_half2_rte(float2, size_t, __global half *);
+void __ovld vstore_half3_rte(float3, size_t, __global half *);
+void __ovld vstore_half4_rte(float4, size_t, __global half *);
+void __ovld vstore_half8_rte(float8, size_t, __global half *);
+void __ovld vstore_half16_rte(float16, size_t, __global half *);
+void __ovld vstore_half2_rtz(float2, size_t, __global half *);
+void __ovld vstore_half3_rtz(float3, size_t, __global half *);
+void __ovld vstore_half4_rtz(float4, size_t, __global half *);
+void __ovld vstore_half8_rtz(float8, size_t, __global half *);
+void __ovld vstore_half16_rtz(float16, size_t, __global half *);
+void __ovld vstore_half2_rtp(float2, size_t, __global half *);
+void __ovld vstore_half3_rtp(float3, size_t, __global half *);
+void __ovld vstore_half4_rtp(float4, size_t, __global half *);
+void __ovld vstore_half8_rtp(float8, size_t, __global half *);
+void __ovld vstore_half16_rtp(float16, size_t, __global half *);
+void __ovld vstore_half2_rtn(float2, size_t, __global half *);
+void __ovld vstore_half3_rtn(float3, size_t, __global half *);
+void __ovld vstore_half4_rtn(float4, size_t, __global half *);
+void __ovld vstore_half8_rtn(float8, size_t, __global half *);
+void __ovld vstore_half16_rtn(float16, size_t, __global half *);
+void __ovld vstore_half2(float2, size_t, __local half *);
+void __ovld vstore_half3(float3, size_t, __local half *);
+void __ovld vstore_half4(float4, size_t, __local half *);
+void __ovld vstore_half8(float8, size_t, __local half *);
+void __ovld vstore_half16(float16, size_t, __local half *);
+void __ovld vstore_half2_rte(float2, size_t, __local half *);
+void __ovld vstore_half3_rte(float3, size_t, __local half *);
+void __ovld vstore_half4_rte(float4, size_t, __local half *);
+void __ovld vstore_half8_rte(float8, size_t, __local half *);
+void __ovld vstore_half16_rte(float16, size_t, __local half *);
+void __ovld vstore_half2_rtz(float2, size_t, __local half *);
+void __ovld vstore_half3_rtz(float3, size_t, __local half *);
+void __ovld vstore_half4_rtz(float4, size_t, __local half *);
+void __ovld vstore_half8_rtz(float8, size_t, __local half *);
+void __ovld vstore_half16_rtz(float16, size_t, __local half *);
+void __ovld vstore_half2_rtp(float2, size_t, __local half *);
+void __ovld vstore_half3_rtp(float3, size_t, __local half *);
+void __ovld vstore_half4_rtp(float4, size_t, __local half *);
+void __ovld vstore_half8_rtp(float8, size_t, __local half *);
+void __ovld vstore_half16_rtp(float16, size_t, __local half *);
+void __ovld vstore_half2_rtn(float2, size_t, __local half *);
+void __ovld vstore_half3_rtn(float3, size_t, __local half *);
+void __ovld vstore_half4_rtn(float4, size_t, __local half *);
+void __ovld vstore_half8_rtn(float8, size_t, __local half *);
+void __ovld vstore_half16_rtn(float16, size_t, __local half *);
+void __ovld vstore_half2(float2, size_t, __private half *);
+void __ovld vstore_half3(float3, size_t, __private half *);
+void __ovld vstore_half4(float4, size_t, __private half *);
+void __ovld vstore_half8(float8, size_t, __private half *);
+void __ovld vstore_half16(float16, size_t, __private half *);
+void __ovld vstore_half2_rte(float2, size_t, __private half *);
+void __ovld vstore_half3_rte(float3, size_t, __private half *);
+void __ovld vstore_half4_rte(float4, size_t, __private half *);
+void __ovld vstore_half8_rte(float8, size_t, __private half *);
+void __ovld vstore_half16_rte(float16, size_t, __private half *);
+void __ovld vstore_half2_rtz(float2, size_t, __private half *);
+void __ovld vstore_half3_rtz(float3, size_t, __private half *);
+void __ovld vstore_half4_rtz(float4, size_t, __private half *);
+void __ovld vstore_half8_rtz(float8, size_t, __private half *);
+void __ovld vstore_half16_rtz(float16, size_t, __private half *);
+void __ovld vstore_half2_rtp(float2, size_t, __private half *);
+void __ovld vstore_half3_rtp(float3, size_t, __private half *);
+void __ovld vstore_half4_rtp(float4, size_t, __private half *);
+void __ovld vstore_half8_rtp(float8, size_t, __private half *);
+void __ovld vstore_half16_rtp(float16, size_t, __private half *);
+void __ovld vstore_half2_rtn(float2, size_t, __private half *);
+void __ovld vstore_half3_rtn(float3, size_t, __private half *);
+void __ovld vstore_half4_rtn(float4, size_t, __private half *);
+void __ovld vstore_half8_rtn(float8, size_t, __private half *);
+void __ovld vstore_half16_rtn(float16, size_t, __private half *);
+#ifdef cl_khr_fp64
+void __ovld vstore_half2(double2, size_t, __global half *);
+void __ovld vstore_half3(double3, size_t, __global half *);
+void __ovld vstore_half4(double4, size_t, __global half *);
+void __ovld vstore_half8(double8, size_t, __global half *);
+void __ovld vstore_half16(double16, size_t, __global half *);
+void __ovld vstore_half2_rte(double2, size_t, __global half *);
+void __ovld vstore_half3_rte(double3, size_t, __global half *);
+void __ovld vstore_half4_rte(double4, size_t, __global half *);
+void __ovld vstore_half8_rte(double8, size_t, __global half *);
+void __ovld vstore_half16_rte(double16, size_t, __global half *);
+void __ovld vstore_half2_rtz(double2, size_t, __global half *);
+void __ovld vstore_half3_rtz(double3, size_t, __global half *);
+void __ovld vstore_half4_rtz(double4, size_t, __global half *);
+void __ovld vstore_half8_rtz(double8, size_t, __global half *);
+void __ovld vstore_half16_rtz(double16, size_t, __global half *);
+void __ovld vstore_half2_rtp(double2, size_t, __global half *);
+void __ovld vstore_half3_rtp(double3, size_t, __global half *);
+void __ovld vstore_half4_rtp(double4, size_t, __global half *);
+void __ovld vstore_half8_rtp(double8, size_t, __global half *);
+void __ovld vstore_half16_rtp(double16, size_t, __global half *);
+void __ovld vstore_half2_rtn(double2, size_t, __global half *);
+void __ovld vstore_half3_rtn(double3, size_t, __global half *);
+void __ovld vstore_half4_rtn(double4, size_t, __global half *);
+void __ovld vstore_half8_rtn(double8, size_t, __global half *);
+void __ovld vstore_half16_rtn(double16, size_t, __global half *);
+void __ovld vstore_half2(double2, size_t, __local half *);
+void __ovld vstore_half3(double3, size_t, __local half *);
+void __ovld vstore_half4(double4, size_t, __local half *);
+void __ovld vstore_half8(double8, size_t, __local half *);
+void __ovld vstore_half16(double16, size_t, __local half *);
+void __ovld vstore_half2_rte(double2, size_t, __local half *);
+void __ovld vstore_half3_rte(double3, size_t, __local half *);
+void __ovld vstore_half4_rte(double4, size_t, __local half *);
+void __ovld vstore_half8_rte(double8, size_t, __local half *);
+void __ovld vstore_half16_rte(double16, size_t, __local half *);
+void __ovld vstore_half2_rtz(double2, size_t, __local half *);
+void __ovld vstore_half3_rtz(double3, size_t, __local half *);
+void __ovld vstore_half4_rtz(double4, size_t, __local half *);
+void __ovld vstore_half8_rtz(double8, size_t, __local half *);
+void __ovld vstore_half16_rtz(double16, size_t, __local half *);
+void __ovld vstore_half2_rtp(double2, size_t, __local half *);
+void __ovld vstore_half3_rtp(double3, size_t, __local half *);
+void __ovld vstore_half4_rtp(double4, size_t, __local half *);
+void __ovld vstore_half8_rtp(double8, size_t, __local half *);
+void __ovld vstore_half16_rtp(double16, size_t, __local half *);
+void __ovld vstore_half2_rtn(double2, size_t, __local half *);
+void __ovld vstore_half3_rtn(double3, size_t, __local half *);
+void __ovld vstore_half4_rtn(double4, size_t, __local half *);
+void __ovld vstore_half8_rtn(double8, size_t, __local half *);
+void __ovld vstore_half16_rtn(double16, size_t, __local half *);
+void __ovld vstore_half2(double2, size_t, __private half *);
+void __ovld vstore_half3(double3, size_t, __private half *);
+void __ovld vstore_half4(double4, size_t, __private half *);
+void __ovld vstore_half8(double8, size_t, __private half *);
+void __ovld vstore_half16(double16, size_t, __private half *);
+void __ovld vstore_half2_rte(double2, size_t, __private half *);
+void __ovld vstore_half3_rte(double3, size_t, __private half *);
+void __ovld vstore_half4_rte(double4, size_t, __private half *);
+void __ovld vstore_half8_rte(double8, size_t, __private half *);
+void __ovld vstore_half16_rte(double16, size_t, __private half *);
+void __ovld vstore_half2_rtz(double2, size_t, __private half *);
+void __ovld vstore_half3_rtz(double3, size_t, __private half *);
+void __ovld vstore_half4_rtz(double4, size_t, __private half *);
+void __ovld vstore_half8_rtz(double8, size_t, __private half *);
+void __ovld vstore_half16_rtz(double16, size_t, __private half *);
+void __ovld vstore_half2_rtp(double2, size_t, __private half *);
+void __ovld vstore_half3_rtp(double3, size_t, __private half *);
+void __ovld vstore_half4_rtp(double4, size_t, __private half *);
+void __ovld vstore_half8_rtp(double8, size_t, __private half *);
+void __ovld vstore_half16_rtp(double16, size_t, __private half *);
+void __ovld vstore_half2_rtn(double2, size_t, __private half *);
+void __ovld vstore_half3_rtn(double3, size_t, __private half *);
+void __ovld vstore_half4_rtn(double4, size_t, __private half *);
+void __ovld vstore_half8_rtn(double8, size_t, __private half *);
+void __ovld vstore_half16_rtn(double16, size_t, __private half *);
+#endif //cl_khr_fp64
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * For n = 1, 2, 4, 8 and 16 read sizeof (halfn)
+ * bytes of data from address (p + (offset * n)).
+ * The data read is interpreted as a halfn value.
+ * The halfn value read is converted to a floatn
+ * value and the floatn value is returned.
+ * The address computed as (p + (offset * n))
+ * must be aligned to sizeof (halfn) bytes.
+ * For n = 3, vloada_half3 reads a half3 from
+ * address (p + (offset * 4)) and returns a float3.
+ * The address computed as (p + (offset * 4))
+ * must be aligned to sizeof (half) * 4 bytes.
+ */
+float2 __ovld __purefn vloada_half2(size_t, const __constant half *);
+float3 __ovld __purefn vloada_half3(size_t, const __constant half *);
+float4 __ovld __purefn vloada_half4(size_t, const __constant half *);
+float8 __ovld __purefn vloada_half8(size_t, const __constant half *);
+float16 __ovld __purefn vloada_half16(size_t, const __constant half *);
+#if defined(__opencl_c_generic_address_space)
+float2 __ovld __purefn vloada_half2(size_t, const half *);
+float3 __ovld __purefn vloada_half3(size_t, const half *);
+float4 __ovld __purefn vloada_half4(size_t, const half *);
+float8 __ovld __purefn vloada_half8(size_t, const half *);
+float16 __ovld __purefn vloada_half16(size_t, const half *);
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+float2 __ovld __purefn vloada_half2(size_t, const __global half *);
+float3 __ovld __purefn vloada_half3(size_t, const __global half *);
+float4 __ovld __purefn vloada_half4(size_t, const __global half *);
+float8 __ovld __purefn vloada_half8(size_t, const __global half *);
+float16 __ovld __purefn vloada_half16(size_t, const __global half *);
+float2 __ovld __purefn vloada_half2(size_t, const __local half *);
+float3 __ovld __purefn vloada_half3(size_t, const __local half *);
+float4 __ovld __purefn vloada_half4(size_t, const __local half *);
+float8 __ovld __purefn vloada_half8(size_t, const __local half *);
+float16 __ovld __purefn vloada_half16(size_t, const __local half *);
+float2 __ovld __purefn vloada_half2(size_t, const __private half *);
+float3 __ovld __purefn vloada_half3(size_t, const __private half *);
+float4 __ovld __purefn vloada_half4(size_t, const __private half *);
+float8 __ovld __purefn vloada_half8(size_t, const __private half *);
+float16 __ovld __purefn vloada_half16(size_t, const __private half *);
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+/**
+ * The floatn value given by data is converted to
+ * a halfn value using the appropriate rounding
+ * mode.
+ * For n = 1, 2, 4, 8 and 16, the halfn value is
+ * written to the address computed as (p + (offset
+ * * n)). The address computed as (p + (offset *
+ * n)) must be aligned to sizeof (halfn) bytes.
+ * For n = 3, the half3 value is written to the
+ * address computed as (p + (offset * 4)). The
+ * address computed as (p + (offset * 4)) must be
+ * aligned to sizeof (half) * 4 bytes.
+ * vstorea_halfn uses the current rounding
+ * mode. The default current rounding mode is
+ * round to nearest even.
+ */
+#if defined(__opencl_c_generic_address_space)
+void __ovld vstorea_half2(float2, size_t, half *);
+void __ovld vstorea_half3(float3, size_t, half *);
+void __ovld vstorea_half4(float4, size_t, half *);
+void __ovld vstorea_half8(float8, size_t, half *);
+void __ovld vstorea_half16(float16, size_t, half *);
+
+void __ovld vstorea_half2_rte(float2, size_t, half *);
+void __ovld vstorea_half3_rte(float3, size_t, half *);
+void __ovld vstorea_half4_rte(float4, size_t, half *);
+void __ovld vstorea_half8_rte(float8, size_t, half *);
+void __ovld vstorea_half16_rte(float16, size_t, half *);
+
+void __ovld vstorea_half2_rtz(float2, size_t, half *);
+void __ovld vstorea_half3_rtz(float3, size_t, half *);
+void __ovld vstorea_half4_rtz(float4, size_t, half *);
+void __ovld vstorea_half8_rtz(float8, size_t, half *);
+void __ovld vstorea_half16_rtz(float16, size_t, half *);
+
+void __ovld vstorea_half2_rtp(float2, size_t, half *);
+void __ovld vstorea_half3_rtp(float3, size_t, half *);
+void __ovld vstorea_half4_rtp(float4, size_t, half *);
+void __ovld vstorea_half8_rtp(float8, size_t, half *);
+void __ovld vstorea_half16_rtp(float16, size_t, half *);
+
+void __ovld vstorea_half2_rtn(float2, size_t, half *);
+void __ovld vstorea_half3_rtn(float3, size_t, half *);
+void __ovld vstorea_half4_rtn(float4, size_t, half *);
+void __ovld vstorea_half8_rtn(float8, size_t, half *);
+void __ovld vstorea_half16_rtn(float16, size_t, half *);
+
+#ifdef cl_khr_fp64
+void __ovld vstorea_half2(double2, size_t, half *);
+void __ovld vstorea_half3(double3, size_t, half *);
+void __ovld vstorea_half4(double4, size_t, half *);
+void __ovld vstorea_half8(double8, size_t, half *);
+void __ovld vstorea_half16(double16, size_t, half *);
+
+void __ovld vstorea_half2_rte(double2, size_t, half *);
+void __ovld vstorea_half3_rte(double3, size_t, half *);
+void __ovld vstorea_half4_rte(double4, size_t, half *);
+void __ovld vstorea_half8_rte(double8, size_t, half *);
+void __ovld vstorea_half16_rte(double16, size_t, half *);
+
+void __ovld vstorea_half2_rtz(double2, size_t, half *);
+void __ovld vstorea_half3_rtz(double3, size_t, half *);
+void __ovld vstorea_half4_rtz(double4, size_t, half *);
+void __ovld vstorea_half8_rtz(double8, size_t, half *);
+void __ovld vstorea_half16_rtz(double16, size_t, half *);
+
+void __ovld vstorea_half2_rtp(double2, size_t, half *);
+void __ovld vstorea_half3_rtp(double3, size_t, half *);
+void __ovld vstorea_half4_rtp(double4, size_t, half *);
+void __ovld vstorea_half8_rtp(double8, size_t, half *);
+void __ovld vstorea_half16_rtp(double16, size_t, half *);
+
+void __ovld vstorea_half2_rtn(double2, size_t, half *);
+void __ovld vstorea_half3_rtn(double3, size_t, half *);
+void __ovld vstorea_half4_rtn(double4, size_t, half *);
+void __ovld vstorea_half8_rtn(double8, size_t, half *);
+void __ovld vstorea_half16_rtn(double16, size_t, half *);
+#endif //cl_khr_fp64
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
+void __ovld vstorea_half2(float2, size_t, __global half *);
+void __ovld vstorea_half3(float3, size_t, __global half *);
+void __ovld vstorea_half4(float4, size_t, __global half *);
+void __ovld vstorea_half8(float8, size_t, __global half *);
+void __ovld vstorea_half16(float16, size_t, __global half *);
+
+void __ovld vstorea_half2_rte(float2, size_t, __global half *);
+void __ovld vstorea_half3_rte(float3, size_t, __global half *);
+void __ovld vstorea_half4_rte(float4, size_t, __global half *);
+void __ovld vstorea_half8_rte(float8, size_t, __global half *);
+void __ovld vstorea_half16_rte(float16, size_t, __global half *);
+
+void __ovld vstorea_half2_rtz(float2, size_t, __global half *);
+void __ovld vstorea_half3_rtz(float3, size_t, __global half *);
+void __ovld vstorea_half4_rtz(float4, size_t, __global half *);
+void __ovld vstorea_half8_rtz(float8, size_t, __global half *);
+void __ovld vstorea_half16_rtz(float16, size_t, __global half *);
+
+void __ovld vstorea_half2_rtp(float2, size_t, __global half *);
+void __ovld vstorea_half3_rtp(float3, size_t, __global half *);
+void __ovld vstorea_half4_rtp(float4, size_t, __global half *);
+void __ovld vstorea_half8_rtp(float8, size_t, __global half *);
+void __ovld vstorea_half16_rtp(float16, size_t, __global half *);
+
+void __ovld vstorea_half2_rtn(float2, size_t, __global half *);
+void __ovld vstorea_half3_rtn(float3, size_t, __global half *);
+void __ovld vstorea_half4_rtn(float4, size_t, __global half *);
+void __ovld vstorea_half8_rtn(float8, size_t, __global half *);
+void __ovld vstorea_half16_rtn(float16, size_t, __global half *);
+
+void __ovld vstorea_half2(float2, size_t, __local half *);
+void __ovld vstorea_half3(float3, size_t, __local half *);
+void __ovld vstorea_half4(float4, size_t, __local half *);
+void __ovld vstorea_half8(float8, size_t, __local half *);
+void __ovld vstorea_half16(float16, size_t, __local half *);
+
+void __ovld vstorea_half2_rte(float2, size_t, __local half *);
+void __ovld vstorea_half3_rte(float3, size_t, __local half *);
+void __ovld vstorea_half4_rte(float4, size_t, __local half *);
+void __ovld vstorea_half8_rte(float8, size_t, __local half *);
+void __ovld vstorea_half16_rte(float16, size_t, __local half *);
+
+void __ovld vstorea_half2_rtz(float2, size_t, __local half *);
+void __ovld vstorea_half3_rtz(float3, size_t, __local half *);
+void __ovld vstorea_half4_rtz(float4, size_t, __local half *);
+void __ovld vstorea_half8_rtz(float8, size_t, __local half *);
+void __ovld vstorea_half16_rtz(float16, size_t, __local half *);
+
+void __ovld vstorea_half2_rtp(float2, size_t, __local half *);
+void __ovld vstorea_half3_rtp(float3, size_t, __local half *);
+void __ovld vstorea_half4_rtp(float4, size_t, __local half *);
+void __ovld vstorea_half8_rtp(float8, size_t, __local half *);
+void __ovld vstorea_half16_rtp(float16, size_t, __local half *);
+
+void __ovld vstorea_half2_rtn(float2, size_t, __local half *);
+void __ovld vstorea_half3_rtn(float3, size_t, __local half *);
+void __ovld vstorea_half4_rtn(float4, size_t, __local half *);
+void __ovld vstorea_half8_rtn(float8, size_t, __local half *);
+void __ovld vstorea_half16_rtn(float16, size_t, __local half *);
+
+void __ovld vstorea_half2(float2, size_t, __private half *);
+void __ovld vstorea_half3(float3, size_t, __private half *);
+void __ovld vstorea_half4(float4, size_t, __private half *);
+void __ovld vstorea_half8(float8, size_t, __private half *);
+void __ovld vstorea_half16(float16, size_t, __private half *);
+
+void __ovld vstorea_half2_rte(float2, size_t, __private half *);
+void __ovld vstorea_half3_rte(float3, size_t, __private half *);
+void __ovld vstorea_half4_rte(float4, size_t, __private half *);
+void __ovld vstorea_half8_rte(float8, size_t, __private half *);
+void __ovld vstorea_half16_rte(float16, size_t, __private half *);
+
+void __ovld vstorea_half2_rtz(float2, size_t, __private half *);
+void __ovld vstorea_half3_rtz(float3, size_t, __private half *);
+void __ovld vstorea_half4_rtz(float4, size_t, __private half *);
+void __ovld vstorea_half8_rtz(float8, size_t, __private half *);
+void __ovld vstorea_half16_rtz(float16, size_t, __private half *);
+
+void __ovld vstorea_half2_rtp(float2, size_t, __private half *);
+void __ovld vstorea_half3_rtp(float3, size_t, __private half *);
+void __ovld vstorea_half4_rtp(float4, size_t, __private half *);
+void __ovld vstorea_half8_rtp(float8, size_t, __private half *);
+void __ovld vstorea_half16_rtp(float16, size_t, __private half *);
+
+void __ovld vstorea_half2_rtn(float2, size_t, __private half *);
+void __ovld vstorea_half3_rtn(float3, size_t, __private half *);
+void __ovld vstorea_half4_rtn(float4, size_t, __private half *);
+void __ovld vstorea_half8_rtn(float8, size_t, __private half *);
+void __ovld vstorea_half16_rtn(float16, size_t, __private half *);
+
+#ifdef cl_khr_fp64
+void __ovld vstorea_half2(double2, size_t, __global half *);
+void __ovld vstorea_half3(double3, size_t, __global half *);
+void __ovld vstorea_half4(double4, size_t, __global half *);
+void __ovld vstorea_half8(double8, size_t, __global half *);
+void __ovld vstorea_half16(double16, size_t, __global half *);
+
+void __ovld vstorea_half2_rte(double2, size_t, __global half *);
+void __ovld vstorea_half3_rte(double3, size_t, __global half *);
+void __ovld vstorea_half4_rte(double4, size_t, __global half *);
+void __ovld vstorea_half8_rte(double8, size_t, __global half *);
+void __ovld vstorea_half16_rte(double16, size_t, __global half *);
+
+void __ovld vstorea_half2_rtz(double2, size_t, __global half *);
+void __ovld vstorea_half3_rtz(double3, size_t, __global half *);
+void __ovld vstorea_half4_rtz(double4, size_t, __global half *);
+void __ovld vstorea_half8_rtz(double8, size_t, __global half *);
+void __ovld vstorea_half16_rtz(double16, size_t, __global half *);
+
+void __ovld vstorea_half2_rtp(double2, size_t, __global half *);
+void __ovld vstorea_half3_rtp(double3, size_t, __global half *);
+void __ovld vstorea_half4_rtp(double4, size_t, __global half *);
+void __ovld vstorea_half8_rtp(double8, size_t, __global half *);
+void __ovld vstorea_half16_rtp(double16, size_t, __global half *);
+
+void __ovld vstorea_half2_rtn(double2, size_t, __global half *);
+void __ovld vstorea_half3_rtn(double3, size_t, __global half *);
+void __ovld vstorea_half4_rtn(double4, size_t, __global half *);
+void __ovld vstorea_half8_rtn(double8, size_t, __global half *);
+void __ovld vstorea_half16_rtn(double16, size_t, __global half *);
+
+void __ovld vstorea_half2(double2, size_t, __local half *);
+void __ovld vstorea_half3(double3, size_t, __local half *);
+void __ovld vstorea_half4(double4, size_t, __local half *);
+void __ovld vstorea_half8(double8, size_t, __local half *);
+void __ovld vstorea_half16(double16, size_t, __local half *);
+
+void __ovld vstorea_half2_rte(double2, size_t, __local half *);
+void __ovld vstorea_half3_rte(double3, size_t, __local half *);
+void __ovld vstorea_half4_rte(double4, size_t, __local half *);
+void __ovld vstorea_half8_rte(double8, size_t, __local half *);
+void __ovld vstorea_half16_rte(double16, size_t, __local half *);
+
+void __ovld vstorea_half2_rtz(double2, size_t, __local half *);
+void __ovld vstorea_half3_rtz(double3, size_t, __local half *);
+void __ovld vstorea_half4_rtz(double4, size_t, __local half *);
+void __ovld vstorea_half8_rtz(double8, size_t, __local half *);
+void __ovld vstorea_half16_rtz(double16, size_t, __local half *);
+
+void __ovld vstorea_half2_rtp(double2, size_t, __local half *);
+void __ovld vstorea_half3_rtp(double3, size_t, __local half *);
+void __ovld vstorea_half4_rtp(double4, size_t, __local half *);
+void __ovld vstorea_half8_rtp(double8, size_t, __local half *);
+void __ovld vstorea_half16_rtp(double16, size_t, __local half *);
+
+void __ovld vstorea_half2_rtn(double2, size_t, __local half *);
+void __ovld vstorea_half3_rtn(double3, size_t, __local half *);
+void __ovld vstorea_half4_rtn(double4, size_t, __local half *);
+void __ovld vstorea_half8_rtn(double8, size_t, __local half *);
+void __ovld vstorea_half16_rtn(double16, size_t, __local half *);
+
+void __ovld vstorea_half2(double2, size_t, __private half *);
+void __ovld vstorea_half3(double3, size_t, __private half *);
+void __ovld vstorea_half4(double4, size_t, __private half *);
+void __ovld vstorea_half8(double8, size_t, __private half *);
+void __ovld vstorea_half16(double16, size_t, __private half *);
+
+void __ovld vstorea_half2_rte(double2, size_t, __private half *);
+void __ovld vstorea_half3_rte(double3, size_t, __private half *);
+void __ovld vstorea_half4_rte(double4, size_t, __private half *);
+void __ovld vstorea_half8_rte(double8, size_t, __private half *);
+void __ovld vstorea_half16_rte(double16, size_t, __private half *);
+
+void __ovld vstorea_half2_rtz(double2, size_t, __private half *);
+void __ovld vstorea_half3_rtz(double3, size_t, __private half *);
+void __ovld vstorea_half4_rtz(double4, size_t, __private half *);
+void __ovld vstorea_half8_rtz(double8, size_t, __private half *);
+void __ovld vstorea_half16_rtz(double16, size_t, __private half *);
+
+void __ovld vstorea_half2_rtp(double2, size_t, __private half *);
+void __ovld vstorea_half3_rtp(double3, size_t, __private half *);
+void __ovld vstorea_half4_rtp(double4, size_t, __private half *);
+void __ovld vstorea_half8_rtp(double8, size_t, __private half *);
+void __ovld vstorea_half16_rtp(double16, size_t, __private half *);
+
+void __ovld vstorea_half2_rtn(double2, size_t, __private half *);
+void __ovld vstorea_half3_rtn(double3, size_t, __private half *);
+void __ovld vstorea_half4_rtn(double4, size_t, __private half *);
+void __ovld vstorea_half8_rtn(double8, size_t, __private half *);
+void __ovld vstorea_half16_rtn(double16, size_t, __private half *);
+#endif //cl_khr_fp64
+#endif //defined(__opencl_c_named_address_space_builtins)
+
+// OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions
+
+/**
+ * All work-items in a work-group executing the kernel
+ * on a processor must execute this function before any
+ * are allowed to continue execution beyond the barrier.
+ * This function must be encountered by all work-items in
+ * a work-group executing the kernel.
+ * If barrier is inside a conditional statement, then all
+ * work-items must enter the conditional if any work-item
+ * enters the conditional statement and executes the
+ * barrier.
+ * If barrer is inside a loop, all work-items must execute
+ * the barrier for each iteration of the loop before any are
+ * allowed to continue execution beyond the barrier.
+ * The barrier function also queues a memory fence
+ * (reads and writes) to ensure correct ordering of
+ * memory operations to local or global memory.
+ * The flags argument specifies the memory address space
+ * and can be set to a combination of the following literal
+ * values.
+ * CLK_LOCAL_MEM_FENCE - The barrier function
+ * will either flush any variables stored in local memory
+ * or queue a memory fence to ensure correct ordering of
+ * memory operations to local memory.
+ * CLK_GLOBAL_MEM_FENCE - The barrier function
+ * will queue a memory fence to ensure correct ordering
+ * of memory operations to global memory. This can be
+ * useful when work-items, for example, write to buffer or
+ * image objects and then want to read the updated data.
+ */
+
+void __ovld __conv barrier(cl_mem_fence_flags);
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+void __ovld __conv work_group_barrier(cl_mem_fence_flags, memory_scope);
+void __ovld __conv work_group_barrier(cl_mem_fence_flags);
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// OpenCL v1.1 s6.11.9, v1.2 s6.12.9 - Explicit Memory Fence Functions
+
+/**
+ * Orders loads and stores of a work-item
+ * executing a kernel. This means that loads
+ * and stores preceding the mem_fence will
+ * be committed to memory before any loads
+ * and stores following the mem_fence.
+ * The flags argument specifies the memory
+ * address space and can be set to a
+ * combination of the following literal
+ * values:
+ * CLK_LOCAL_MEM_FENCE
+ * CLK_GLOBAL_MEM_FENCE.
+ */
+void __ovld mem_fence(cl_mem_fence_flags);
+
+/**
+ * Read memory barrier that orders only
+ * loads.
+ * The flags argument specifies the memory
+ * address space and can be set to a
+ * combination of the following literal
+ * values:
+ * CLK_LOCAL_MEM_FENCE
+ * CLK_GLOBAL_MEM_FENCE.
+ */
+void __ovld read_mem_fence(cl_mem_fence_flags);
+
+/**
+ * Write memory barrier that orders only
+ * stores.
+ * The flags argument specifies the memory
+ * address space and can be set to a
+ * combination of the following literal
+ * values:
+ * CLK_LOCAL_MEM_FENCE
+ * CLK_GLOBAL_MEM_FENCE.
+ */
+void __ovld write_mem_fence(cl_mem_fence_flags);
+
+// OpenCL v2.0 s6.13.9 - Address Space Qualifier Functions
+
+#if defined(__opencl_c_generic_address_space)
+cl_mem_fence_flags __ovld get_fence(const void *ptr);
+cl_mem_fence_flags __ovld get_fence(void *ptr);
+
+/**
+ * Builtin functions to_global, to_local, and to_private need to be declared as Clang builtin functions
+ * and checked in Sema since they should be declared as
+ *   addr gentype* to_addr (gentype*);
+ * where gentype is builtin type or user defined type.
+ */
+
+#endif //defined(__opencl_c_generic_address_space)
+
+// OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10 - Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch
+
+/**
+ * event_t async_work_group_copy (
+ * __global gentype *dst,
+ * const __local gentype *src,
+ * size_t num_elements,
+ * event_t event)
+ * Perform an async copy of num_elements
+ * gentype elements from src to dst. The async
+ * copy is performed by all work-items in a workgroup
+ * and this built-in function must therefore
+ * be encountered by all work-items in a workgroup
+ * executing the kernel with the same
+ * argument values; otherwise the results are
+ * undefined.
+ * Returns an event object that can be used by
+ * wait_group_events to wait for the async copy
+ * to finish. The event argument can also be used
+ * to associate the async_work_group_copy with
+ * a previous async copy allowing an event to be
+ * shared by multiple async copies; otherwise event
+ * should be zero.
+ * If event argument is non-zero, the event object
+ * supplied in event argument will be returned.
+ * This function does not perform any implicit
+ * synchronization of source data such as using a
+ * barrier before performing the copy.
+ */
+event_t __ovld async_work_group_copy(__local char *, const __global char *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uchar *, const __global uchar *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local short *, const __global short *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ushort *, const __global ushort *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local int *, const __global int *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uint *, const __global uint *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local long *, const __global long *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ulong *, const __global ulong *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local float *, const __global float *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local char2 *, const __global char2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uchar2 *, const __global uchar2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local short2 *, const __global short2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ushort2 *, const __global ushort2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local int2 *, const __global int2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uint2 *, const __global uint2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local long2 *, const __global long2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ulong2 *, const __global ulong2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local float2 *, const __global float2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local char3 *, const __global char3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uchar3 *, const __global uchar3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local short3 *, const __global short3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ushort3 *, const __global ushort3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local int3 *, const __global int3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uint3 *, const __global uint3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local long3 *, const __global long3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ulong3 *, const __global ulong3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local float3 *, const __global float3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local char4 *, const __global char4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uchar4 *, const __global uchar4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local short4 *, const __global short4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ushort4 *, const __global ushort4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local int4 *, const __global int4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uint4 *, const __global uint4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local long4 *, const __global long4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ulong4 *, const __global ulong4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local float4 *, const __global float4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local char8 *, const __global char8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uchar8 *, const __global uchar8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local short8 *, const __global short8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ushort8 *, const __global ushort8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local int8 *, const __global int8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uint8 *, const __global uint8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local long8 *, const __global long8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ulong8 *, const __global ulong8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local float8 *, const __global float8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local char16 *, const __global char16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uchar16 *, const __global uchar16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local short16 *, const __global short16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ushort16 *, const __global ushort16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local int16 *, const __global int16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local uint16 *, const __global uint16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local long16 *, const __global long16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local ulong16 *, const __global ulong16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local float16 *, const __global float16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global char *, const __local char *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uchar *, const __local uchar *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global short *, const __local short *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ushort *, const __local ushort *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global int *, const __local int *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uint *, const __local uint *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global long *, const __local long *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ulong *, const __local ulong *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global float *, const __local float *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global char2 *, const __local char2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uchar2 *, const __local uchar2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global short2 *, const __local short2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ushort2 *, const __local ushort2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global int2 *, const __local int2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uint2 *, const __local uint2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global long2 *, const __local long2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ulong2 *, const __local ulong2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global float2 *, const __local float2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global char3 *, const __local char3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uchar3 *, const __local uchar3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global short3 *, const __local short3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ushort3 *, const __local ushort3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global int3 *, const __local int3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uint3 *, const __local uint3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global long3 *, const __local long3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ulong3 *, const __local ulong3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global float3 *, const __local float3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global char4 *, const __local char4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uchar4 *, const __local uchar4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global short4 *, const __local short4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ushort4 *, const __local ushort4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global int4 *, const __local int4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uint4 *, const __local uint4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global long4 *, const __local long4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ulong4 *, const __local ulong4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global float4 *, const __local float4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global char8 *, const __local char8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uchar8 *, const __local uchar8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global short8 *, const __local short8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ushort8 *, const __local ushort8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global int8 *, const __local int8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uint8 *, const __local uint8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global long8 *, const __local long8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ulong8 *, const __local ulong8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global float8 *, const __local float8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global char16 *, const __local char16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uchar16 *, const __local uchar16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global short16 *, const __local short16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ushort16 *, const __local ushort16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global int16 *, const __local int16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global uint16 *, const __local uint16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global long16 *, const __local long16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global ulong16 *, const __local ulong16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global float16 *, const __local float16 *, size_t, event_t);
+#ifdef cl_khr_fp64
+event_t __ovld async_work_group_copy(__local double *, const __global double *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local double2 *, const __global double2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local double3 *, const __global double3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local double4 *, const __global double4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local double8 *, const __global double8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local double16 *, const __global double16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global double *, const __local double *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global double2 *, const __local double2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global double3 *, const __local double3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global double4 *, const __local double4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global double8 *, const __local double8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global double16 *, const __local double16 *, size_t, event_t);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+event_t __ovld async_work_group_copy(__local half *, const __global half *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local half2 *, const __global half2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local half3 *, const __global half3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local half4 *, const __global half4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local half8 *, const __global half8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__local half16 *, const __global half16 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global half *, const __local half *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global half2 *, const __local half2 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global half3 *, const __local half3 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global half4 *, const __local half4 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global half8 *, const __local half8 *, size_t, event_t);
+event_t __ovld async_work_group_copy(__global half16 *, const __local half16 *, size_t, event_t);
+#endif //cl_khr_fp16
+
+/**
+ * Perform an async gather of num_elements
+ * gentype elements from src to dst. The
+ * src_stride is the stride in elements for each
+ * gentype element read from src. The dst_stride
+ * is the stride in elements for each gentype
+ * element written to dst. The async gather is
+ * performed by all work-items in a work-group.
+ * This built-in function must therefore be
+ * encountered by all work-items in a work-group
+ * executing the kernel with the same argument
+ * values; otherwise the results are undefined.
+ * Returns an event object that can be used by
+ * wait_group_events to wait for the async copy
+ * to finish. The event argument can also be used
+ * to associate the
+ * async_work_group_strided_copy with a
+ * previous async copy allowing an event to be
+ * shared by multiple async copies; otherwise event
+ * should be zero.
+ * If event argument is non-zero, the event object
+ * supplied in event argument will be returned.
+ * This function does not perform any implicit
+ * synchronization of source data such as using a
+ * barrier before performing the copy.
+ */
+event_t __ovld async_work_group_strided_copy(__local char *, const __global char *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uchar *, const __global uchar *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local short *, const __global short *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ushort *, const __global ushort *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local int *, const __global int *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uint *, const __global uint *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local long *, const __global long *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ulong *, const __global ulong *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local float *, const __global float *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local char2 *, const __global char2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uchar2 *, const __global uchar2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local short2 *, const __global short2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ushort2 *, const __global ushort2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local int2 *, const __global int2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uint2 *, const __global uint2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local long2 *, const __global long2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ulong2 *, const __global ulong2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local float2 *, const __global float2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local char3 *, const __global char3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uchar3 *, const __global uchar3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local short3 *, const __global short3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ushort3 *, const __global ushort3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local int3 *, const __global int3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uint3 *, const __global uint3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local long3 *, const __global long3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ulong3 *, const __global ulong3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local float3 *, const __global float3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local char4 *, const __global char4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uchar4 *, const __global uchar4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local short4 *, const __global short4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ushort4 *, const __global ushort4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local int4 *, const __global int4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uint4 *, const __global uint4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local long4 *, const __global long4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ulong4 *, const __global ulong4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local float4 *, const __global float4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local char8 *, const __global char8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uchar8 *, const __global uchar8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local short8 *, const __global short8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ushort8 *, const __global ushort8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local int8 *, const __global int8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uint8 *, const __global uint8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local long8 *, const __global long8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ulong8 *, const __global ulong8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local float8 *, const __global float8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local char16 *, const __global char16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uchar16 *, const __global uchar16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local short16 *, const __global short16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ushort16 *, const __global ushort16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local int16 *, const __global int16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local uint16 *, const __global uint16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local long16 *, const __global long16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local ulong16 *, const __global ulong16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local float16 *, const __global float16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global char *, const __local char *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uchar *, const __local uchar *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global short *, const __local short *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ushort *, const __local ushort *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global int *, const __local int *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uint *, const __local uint *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global long *, const __local long *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ulong *, const __local ulong *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global float *, const __local float *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global char2 *, const __local char2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uchar2 *, const __local uchar2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global short2 *, const __local short2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ushort2 *, const __local ushort2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global int2 *, const __local int2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uint2 *, const __local uint2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global long2 *, const __local long2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ulong2 *, const __local ulong2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global float2 *, const __local float2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global char3 *, const __local char3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uchar3 *, const __local uchar3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global short3 *, const __local short3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ushort3 *, const __local ushort3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global int3 *, const __local int3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uint3 *, const __local uint3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global long3 *, const __local long3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ulong3 *, const __local ulong3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global float3 *, const __local float3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global char4 *, const __local char4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uchar4 *, const __local uchar4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global short4 *, const __local short4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ushort4 *, const __local ushort4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global int4 *, const __local int4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uint4 *, const __local uint4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global long4 *, const __local long4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ulong4 *, const __local ulong4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global float4 *, const __local float4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global char8 *, const __local char8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uchar8 *, const __local uchar8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global short8 *, const __local short8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ushort8 *, const __local ushort8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global int8 *, const __local int8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uint8 *, const __local uint8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global long8 *, const __local long8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ulong8 *, const __local ulong8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global float8 *, const __local float8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global char16 *, const __local char16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uchar16 *, const __local uchar16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global short16 *, const __local short16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ushort16 *, const __local ushort16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global int16 *, const __local int16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global uint16 *, const __local uint16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global long16 *, const __local long16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global ulong16 *, const __local ulong16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global float16 *, const __local float16 *, size_t, size_t, event_t);
+#ifdef cl_khr_fp64
+event_t __ovld async_work_group_strided_copy(__local double *, const __global double *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local double2 *, const __global double2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local double3 *, const __global double3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local double4 *, const __global double4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local double8 *, const __global double8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local double16 *, const __global double16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global double *, const __local double *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global double2 *, const __local double2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global double3 *, const __local double3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global double4 *, const __local double4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global double8 *, const __local double8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global double16 *, const __local double16 *, size_t, size_t, event_t);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+event_t __ovld async_work_group_strided_copy(__local half *, const __global half *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local half2 *, const __global half2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local half3 *, const __global half3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local half4 *, const __global half4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local half8 *, const __global half8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__local half16 *, const __global half16 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global half *, const __local half *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global half2 *, const __local half2 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global half3 *, const __local half3 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global half4 *, const __local half4 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global half8 *, const __local half8 *, size_t, size_t, event_t);
+event_t __ovld async_work_group_strided_copy(__global half16 *, const __local half16 *, size_t, size_t, event_t);
+#endif //cl_khr_fp16
+
+/**
+ * Wait for events that identify the
+ * async_work_group_copy operations to
+ * complete. The event objects specified in
+ * event_list will be released after the wait is
+ * performed.
+ * This function must be encountered by all workitems
+ * in a work-group executing the kernel with
+ * the same num_events and event objects specified
+ * in event_list; otherwise the results are undefined.
+ */
+void __ovld wait_group_events(int, event_t *);
+
+/**
+ * Prefetch num_elements * sizeof(gentype)
+ * bytes into the global cache. The prefetch
+ * instruction is applied to a work-item in a workgroup
+ * and does not affect the functional
+ * behavior of the kernel.
+ */
+void __ovld prefetch(const __global char *, size_t);
+void __ovld prefetch(const __global uchar *, size_t);
+void __ovld prefetch(const __global short *, size_t);
+void __ovld prefetch(const __global ushort *, size_t);
+void __ovld prefetch(const __global int *, size_t);
+void __ovld prefetch(const __global uint *, size_t);
+void __ovld prefetch(const __global long *, size_t);
+void __ovld prefetch(const __global ulong *, size_t);
+void __ovld prefetch(const __global float *, size_t);
+void __ovld prefetch(const __global char2 *, size_t);
+void __ovld prefetch(const __global uchar2 *, size_t);
+void __ovld prefetch(const __global short2 *, size_t);
+void __ovld prefetch(const __global ushort2 *, size_t);
+void __ovld prefetch(const __global int2 *, size_t);
+void __ovld prefetch(const __global uint2 *, size_t);
+void __ovld prefetch(const __global long2 *, size_t);
+void __ovld prefetch(const __global ulong2 *, size_t);
+void __ovld prefetch(const __global float2 *, size_t);
+void __ovld prefetch(const __global char3 *, size_t);
+void __ovld prefetch(const __global uchar3 *, size_t);
+void __ovld prefetch(const __global short3 *, size_t);
+void __ovld prefetch(const __global ushort3 *, size_t);
+void __ovld prefetch(const __global int3 *, size_t);
+void __ovld prefetch(const __global uint3 *, size_t);
+void __ovld prefetch(const __global long3 *, size_t);
+void __ovld prefetch(const __global ulong3 *, size_t);
+void __ovld prefetch(const __global float3 *, size_t);
+void __ovld prefetch(const __global char4 *, size_t);
+void __ovld prefetch(const __global uchar4 *, size_t);
+void __ovld prefetch(const __global short4 *, size_t);
+void __ovld prefetch(const __global ushort4 *, size_t);
+void __ovld prefetch(const __global int4 *, size_t);
+void __ovld prefetch(const __global uint4 *, size_t);
+void __ovld prefetch(const __global long4 *, size_t);
+void __ovld prefetch(const __global ulong4 *, size_t);
+void __ovld prefetch(const __global float4 *, size_t);
+void __ovld prefetch(const __global char8 *, size_t);
+void __ovld prefetch(const __global uchar8 *, size_t);
+void __ovld prefetch(const __global short8 *, size_t);
+void __ovld prefetch(const __global ushort8 *, size_t);
+void __ovld prefetch(const __global int8 *, size_t);
+void __ovld prefetch(const __global uint8 *, size_t);
+void __ovld prefetch(const __global long8 *, size_t);
+void __ovld prefetch(const __global ulong8 *, size_t);
+void __ovld prefetch(const __global float8 *, size_t);
+void __ovld prefetch(const __global char16 *, size_t);
+void __ovld prefetch(const __global uchar16 *, size_t);
+void __ovld prefetch(const __global short16 *, size_t);
+void __ovld prefetch(const __global ushort16 *, size_t);
+void __ovld prefetch(const __global int16 *, size_t);
+void __ovld prefetch(const __global uint16 *, size_t);
+void __ovld prefetch(const __global long16 *, size_t);
+void __ovld prefetch(const __global ulong16 *, size_t);
+void __ovld prefetch(const __global float16 *, size_t);
+#ifdef cl_khr_fp64
+void __ovld prefetch(const __global double *, size_t);
+void __ovld prefetch(const __global double2 *, size_t);
+void __ovld prefetch(const __global double3 *, size_t);
+void __ovld prefetch(const __global double4 *, size_t);
+void __ovld prefetch(const __global double8 *, size_t);
+void __ovld prefetch(const __global double16 *, size_t);
+#endif //cl_khr_fp64
+#ifdef cl_khr_fp16
+void __ovld prefetch(const __global half *, size_t);
+void __ovld prefetch(const __global half2 *, size_t);
+void __ovld prefetch(const __global half3 *, size_t);
+void __ovld prefetch(const __global half4 *, size_t);
+void __ovld prefetch(const __global half8 *, size_t);
+void __ovld prefetch(const __global half16 *, size_t);
+#endif // cl_khr_fp16
+
+// OpenCL v1.1 s6.11.1, v1.2 s6.12.11 - Atomic Functions
+
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable
+#endif
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old + val) and store result at location
+ * pointed by p. The function returns old.
+ */
+int __ovld atomic_add(volatile __global int *, int);
+uint __ovld atomic_add(volatile __global uint *, uint);
+int __ovld atomic_add(volatile __local int *, int);
+uint __ovld atomic_add(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_add(volatile int *, int);
+uint __ovld atomic_add(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_base_atomics)
+int __ovld atom_add(volatile __global int *, int);
+uint __ovld atom_add(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_base_atomics)
+int __ovld atom_add(volatile __local int *, int);
+uint __ovld atom_add(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_base_atomics)
+long __ovld atom_add(volatile __global long *, long);
+ulong __ovld atom_add(volatile __global ulong *, ulong);
+long __ovld atom_add(volatile __local long *, long);
+ulong __ovld atom_add(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old) stored at location pointed by p.
+ * Compute (old - val) and store result at location pointed by p. The function
+ * returns old.
+ */
+int __ovld atomic_sub(volatile __global int *, int);
+uint __ovld atomic_sub(volatile __global uint *, uint);
+int __ovld atomic_sub(volatile __local int *, int);
+uint __ovld atomic_sub(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_sub(volatile int *, int);
+uint __ovld atomic_sub(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_base_atomics)
+int __ovld atom_sub(volatile __global int *, int);
+uint __ovld atom_sub(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_base_atomics)
+int __ovld atom_sub(volatile __local int *, int);
+uint __ovld atom_sub(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_base_atomics)
+long __ovld atom_sub(volatile __global long *, long);
+ulong __ovld atom_sub(volatile __global ulong *, ulong);
+long __ovld atom_sub(volatile __local long *, long);
+ulong __ovld atom_sub(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Swaps the old value stored at location p
+ * with new value given by val. Returns old
+ * value.
+ */
+int __ovld atomic_xchg(volatile __global int *, int);
+uint __ovld atomic_xchg(volatile __global uint *, uint);
+int __ovld atomic_xchg(volatile __local int *, int);
+uint __ovld atomic_xchg(volatile __local uint *, uint);
+float __ovld atomic_xchg(volatile __global float *, float);
+float __ovld atomic_xchg(volatile __local float *, float);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_xchg(volatile int *, int);
+uint __ovld atomic_xchg(volatile uint *, uint);
+float __ovld atomic_xchg(volatile float *, float);
+#endif
+
+#if defined(cl_khr_global_int32_base_atomics)
+int __ovld atom_xchg(volatile __global int *, int);
+uint __ovld atom_xchg(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_base_atomics)
+int __ovld atom_xchg(volatile __local int *, int);
+uint __ovld atom_xchg(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_base_atomics)
+long __ovld atom_xchg(volatile __global long *, long);
+long __ovld atom_xchg(volatile __local long *, long);
+ulong __ovld atom_xchg(volatile __global ulong *, ulong);
+ulong __ovld atom_xchg(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old + 1) and store result at location
+ * pointed by p. The function returns old.
+ */
+int __ovld atomic_inc(volatile __global int *);
+uint __ovld atomic_inc(volatile __global uint *);
+int __ovld atomic_inc(volatile __local int *);
+uint __ovld atomic_inc(volatile __local uint *);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_inc(volatile int *);
+uint __ovld atomic_inc(volatile uint *);
+#endif
+
+#if defined(cl_khr_global_int32_base_atomics)
+int __ovld atom_inc(volatile __global int *);
+uint __ovld atom_inc(volatile __global uint *);
+#endif
+#if defined(cl_khr_local_int32_base_atomics)
+int __ovld atom_inc(volatile __local int *);
+uint __ovld atom_inc(volatile __local uint *);
+#endif
+
+#if defined(cl_khr_int64_base_atomics)
+long __ovld atom_inc(volatile __global long *);
+ulong __ovld atom_inc(volatile __global ulong *);
+long __ovld atom_inc(volatile __local long *);
+ulong __ovld atom_inc(volatile __local ulong *);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old - 1) and store result at location
+ * pointed by p. The function returns old.
+ */
+int __ovld atomic_dec(volatile __global int *);
+uint __ovld atomic_dec(volatile __global uint *);
+int __ovld atomic_dec(volatile __local int *);
+uint __ovld atomic_dec(volatile __local uint *);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_dec(volatile int *);
+uint __ovld atomic_dec(volatile uint *);
+#endif
+
+#if defined(cl_khr_global_int32_base_atomics)
+int __ovld atom_dec(volatile __global int *);
+uint __ovld atom_dec(volatile __global uint *);
+#endif
+#if defined(cl_khr_local_int32_base_atomics)
+int __ovld atom_dec(volatile __local int *);
+uint __ovld atom_dec(volatile __local uint *);
+#endif
+
+#if defined(cl_khr_int64_base_atomics)
+long __ovld atom_dec(volatile __global long *);
+ulong __ovld atom_dec(volatile __global ulong *);
+long __ovld atom_dec(volatile __local long *);
+ulong __ovld atom_dec(volatile __local ulong *);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old == cmp) ? val : old and store result at
+ * location pointed by p. The function
+ * returns old.
+ */
+int __ovld atomic_cmpxchg(volatile __global int *, int, int);
+uint __ovld atomic_cmpxchg(volatile __global uint *, uint, uint);
+int __ovld atomic_cmpxchg(volatile __local int *, int, int);
+uint __ovld atomic_cmpxchg(volatile __local uint *, uint, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_cmpxchg(volatile int *, int, int);
+uint __ovld atomic_cmpxchg(volatile uint *, uint, uint);
+#endif
+
+#if defined(cl_khr_global_int32_base_atomics)
+int __ovld atom_cmpxchg(volatile __global int *, int, int);
+uint __ovld atom_cmpxchg(volatile __global uint *, uint, uint);
+#endif
+#if defined(cl_khr_local_int32_base_atomics)
+int __ovld atom_cmpxchg(volatile __local int *, int, int);
+uint __ovld atom_cmpxchg(volatile __local uint *, uint, uint);
+#endif
+
+#if defined(cl_khr_int64_base_atomics)
+long __ovld atom_cmpxchg(volatile __global long *, long, long);
+ulong __ovld atom_cmpxchg(volatile __global ulong *, ulong, ulong);
+long __ovld atom_cmpxchg(volatile __local long *, long, long);
+ulong __ovld atom_cmpxchg(volatile __local ulong *, ulong, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * min(old, val) and store minimum value at
+ * location pointed by p. The function
+ * returns old.
+ */
+int __ovld atomic_min(volatile __global int *, int);
+uint __ovld atomic_min(volatile __global uint *, uint);
+int __ovld atomic_min(volatile __local int *, int);
+uint __ovld atomic_min(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_min(volatile int *, int);
+uint __ovld atomic_min(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_extended_atomics)
+int __ovld atom_min(volatile __global int *, int);
+uint __ovld atom_min(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_extended_atomics)
+int __ovld atom_min(volatile __local int *, int);
+uint __ovld atom_min(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_extended_atomics)
+long __ovld atom_min(volatile __global long *, long);
+ulong __ovld atom_min(volatile __global ulong *, ulong);
+long __ovld atom_min(volatile __local long *, long);
+ulong __ovld atom_min(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * max(old, val) and store maximum value at
+ * location pointed by p. The function
+ * returns old.
+ */
+int __ovld atomic_max(volatile __global int *, int);
+uint __ovld atomic_max(volatile __global uint *, uint);
+int __ovld atomic_max(volatile __local int *, int);
+uint __ovld atomic_max(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_max(volatile int *, int);
+uint __ovld atomic_max(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_extended_atomics)
+int __ovld atom_max(volatile __global int *, int);
+uint __ovld atom_max(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_extended_atomics)
+int __ovld atom_max(volatile __local int *, int);
+uint __ovld atom_max(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_extended_atomics)
+long __ovld atom_max(volatile __global long *, long);
+ulong __ovld atom_max(volatile __global ulong *, ulong);
+long __ovld atom_max(volatile __local long *, long);
+ulong __ovld atom_max(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old & val) and store result at location
+ * pointed by p. The function returns old.
+ */
+int __ovld atomic_and(volatile __global int *, int);
+uint __ovld atomic_and(volatile __global uint *, uint);
+int __ovld atomic_and(volatile __local int *, int);
+uint __ovld atomic_and(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_and(volatile int *, int);
+uint __ovld atomic_and(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_extended_atomics)
+int __ovld atom_and(volatile __global int *, int);
+uint __ovld atom_and(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_extended_atomics)
+int __ovld atom_and(volatile __local int *, int);
+uint __ovld atom_and(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_extended_atomics)
+long __ovld atom_and(volatile __global long *, long);
+ulong __ovld atom_and(volatile __global ulong *, ulong);
+long __ovld atom_and(volatile __local long *, long);
+ulong __ovld atom_and(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old | val) and store result at location
+ * pointed by p. The function returns old.
+ */
+int __ovld atomic_or(volatile __global int *, int);
+uint __ovld atomic_or(volatile __global uint *, uint);
+int __ovld atomic_or(volatile __local int *, int);
+uint __ovld atomic_or(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_or(volatile int *, int);
+uint __ovld atomic_or(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_extended_atomics)
+int __ovld atom_or(volatile __global int *, int);
+uint __ovld atom_or(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_extended_atomics)
+int __ovld atom_or(volatile __local int *, int);
+uint __ovld atom_or(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_extended_atomics)
+long __ovld atom_or(volatile __global long *, long);
+ulong __ovld atom_or(volatile __global ulong *, ulong);
+long __ovld atom_or(volatile __local long *, long);
+ulong __ovld atom_or(volatile __local ulong *, ulong);
+#endif
+
+/**
+ * Read the 32-bit value (referred to as old)
+ * stored at location pointed by p. Compute
+ * (old ^ val) and store result at location
+ * pointed by p. The function returns old.
+ */
+int __ovld atomic_xor(volatile __global int *, int);
+uint __ovld atomic_xor(volatile __global uint *, uint);
+int __ovld atomic_xor(volatile __local int *, int);
+uint __ovld atomic_xor(volatile __local uint *, uint);
+#ifdef __OPENCL_CPP_VERSION__
+int __ovld atomic_xor(volatile int *, int);
+uint __ovld atomic_xor(volatile uint *, uint);
+#endif
+
+#if defined(cl_khr_global_int32_extended_atomics)
+int __ovld atom_xor(volatile __global int *, int);
+uint __ovld atom_xor(volatile __global uint *, uint);
+#endif
+#if defined(cl_khr_local_int32_extended_atomics)
+int __ovld atom_xor(volatile __local int *, int);
+uint __ovld atom_xor(volatile __local uint *, uint);
+#endif
+
+#if defined(cl_khr_int64_extended_atomics)
+long __ovld atom_xor(volatile __global long *, long);
+ulong __ovld atom_xor(volatile __global ulong *, ulong);
+long __ovld atom_xor(volatile __local long *, long);
+ulong __ovld atom_xor(volatile __local ulong *, ulong);
+#endif
+
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : disable
+#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : disable
+#endif
+
+// OpenCL v2.0 s6.13.11 - Atomics Functions
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// double atomics support requires extensions cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable
+#endif
+
+// atomic_init()
+#if defined(__opencl_c_generic_address_space)
+void __ovld atomic_init(volatile atomic_int *, int);
+void __ovld atomic_init(volatile atomic_uint *, uint);
+void __ovld atomic_init(volatile atomic_float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+void __ovld atomic_init(volatile atomic_long *, long);
+void __ovld atomic_init(volatile atomic_ulong *, ulong);
+#ifdef cl_khr_fp64
+void __ovld atomic_init(volatile atomic_double *, double);
+#endif //cl_khr_fp64
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+void __ovld atomic_init(volatile __global atomic_int *, int);
+void __ovld atomic_init(volatile __local atomic_int *, int);
+void __ovld atomic_init(volatile __global atomic_uint *, uint);
+void __ovld atomic_init(volatile __local atomic_uint *, uint);
+void __ovld atomic_init(volatile __global atomic_float *, float);
+void __ovld atomic_init(volatile __local atomic_float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+void __ovld atomic_init(volatile __global atomic_long *, long);
+void __ovld atomic_init(volatile __local atomic_long *, long);
+void __ovld atomic_init(volatile __global atomic_ulong *, ulong);
+void __ovld atomic_init(volatile __local atomic_ulong *, ulong);
+#ifdef cl_khr_fp64
+void __ovld atomic_init(volatile __global atomic_double *, double);
+void __ovld atomic_init(volatile __local atomic_double *, double);
+#endif //cl_khr_fp64
+#endif
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+
+// atomic_work_item_fence()
+void __ovld atomic_work_item_fence(cl_mem_fence_flags, memory_order, memory_scope);
+
+// atomic_fetch()
+// OpenCL v2.0 s6.13.11.7.5:
+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument can be ptrdiff_t.
+
+#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_fetch_add(volatile atomic_int *, int);
+uint __ovld atomic_fetch_add(volatile atomic_uint *, uint);
+int __ovld atomic_fetch_sub(volatile atomic_int *, int);
+uint __ovld atomic_fetch_sub(volatile atomic_uint *, uint);
+int __ovld atomic_fetch_or(volatile atomic_int *, int);
+uint __ovld atomic_fetch_or(volatile atomic_uint *, uint);
+int __ovld atomic_fetch_xor(volatile atomic_int *, int);
+uint __ovld atomic_fetch_xor(volatile atomic_uint *, uint);
+int __ovld atomic_fetch_and(volatile atomic_int *, int);
+uint __ovld atomic_fetch_and(volatile atomic_uint *, uint);
+int __ovld atomic_fetch_min(volatile atomic_int *, int);
+uint __ovld atomic_fetch_min(volatile atomic_uint *, uint);
+int __ovld atomic_fetch_max(volatile atomic_int *, int);
+uint __ovld atomic_fetch_max(volatile atomic_uint *, uint);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+long __ovld atomic_fetch_add(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_add(volatile atomic_ulong *, ulong);
+long __ovld atomic_fetch_sub(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_sub(volatile atomic_ulong *, ulong);
+long __ovld atomic_fetch_or(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_or(volatile atomic_ulong *, ulong);
+long __ovld atomic_fetch_xor(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_xor(volatile atomic_ulong *, ulong);
+long __ovld atomic_fetch_and(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_and(volatile atomic_ulong *, ulong);
+long __ovld atomic_fetch_min(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_min(volatile atomic_ulong *, ulong);
+long __ovld atomic_fetch_max(volatile atomic_long *, long);
+ulong __ovld atomic_fetch_max(volatile atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *, ptrdiff_t);
+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *, ptrdiff_t);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_fetch_add(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_add(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_add(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_add(volatile __local atomic_uint *, uint);
+int __ovld atomic_fetch_sub(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_sub(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_sub(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_sub(volatile __local atomic_uint *, uint);
+int __ovld atomic_fetch_or(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_or(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_or(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_or(volatile __local atomic_uint *, uint);
+int __ovld atomic_fetch_xor(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_xor(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_xor(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_xor(volatile __local atomic_uint *, uint);
+int __ovld atomic_fetch_and(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_and(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_and(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_and(volatile __local atomic_uint *, uint);
+int __ovld atomic_fetch_min(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_min(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_min(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_min(volatile __local atomic_uint *, uint);
+int __ovld atomic_fetch_max(volatile __global atomic_int *, int);
+int __ovld atomic_fetch_max(volatile __local atomic_int *, int);
+uint __ovld atomic_fetch_max(volatile __global atomic_uint *, uint);
+uint __ovld atomic_fetch_max(volatile __local atomic_uint *, uint);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+long __ovld atomic_fetch_add(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_add(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_add(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_add(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_add(volatile __global atomic_uintptr_t *, ptrdiff_t);
+uintptr_t __ovld atomic_fetch_add(volatile __local atomic_uintptr_t *, ptrdiff_t);
+long __ovld atomic_fetch_sub(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_sub(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_sub(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_sub(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_sub(volatile __global atomic_uintptr_t *, ptrdiff_t);
+uintptr_t __ovld atomic_fetch_sub(volatile __local atomic_uintptr_t *, ptrdiff_t);
+long __ovld atomic_fetch_or(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_or(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_or(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_or(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_or(volatile __global atomic_uintptr_t *, intptr_t);
+uintptr_t __ovld atomic_fetch_or(volatile __local atomic_uintptr_t *, intptr_t);
+intptr_t __ovld atomic_fetch_or(volatile __global atomic_intptr_t *, uintptr_t);
+intptr_t __ovld atomic_fetch_or(volatile __local atomic_intptr_t *, uintptr_t);
+long __ovld atomic_fetch_xor(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_xor(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_xor(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_xor(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_xor(volatile __global atomic_uintptr_t *, intptr_t);
+uintptr_t __ovld atomic_fetch_xor(volatile __local atomic_uintptr_t *, intptr_t);
+intptr_t __ovld atomic_fetch_xor(volatile __global atomic_intptr_t *, uintptr_t);
+intptr_t __ovld atomic_fetch_xor(volatile __local atomic_intptr_t *, uintptr_t);
+long __ovld atomic_fetch_and(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_and(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_and(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_and(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_and(volatile __global atomic_uintptr_t *, intptr_t);
+uintptr_t __ovld atomic_fetch_and(volatile __local atomic_uintptr_t *, intptr_t);
+intptr_t __ovld atomic_fetch_and(volatile __global atomic_intptr_t *, uintptr_t);
+intptr_t __ovld atomic_fetch_and(volatile __local atomic_intptr_t *, uintptr_t);
+long __ovld atomic_fetch_min(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_min(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_min(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_min(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_min(volatile __global atomic_uintptr_t *, intptr_t);
+uintptr_t __ovld atomic_fetch_min(volatile __local atomic_uintptr_t *, intptr_t);
+intptr_t __ovld atomic_fetch_min(volatile __global atomic_intptr_t *, uintptr_t);
+intptr_t __ovld atomic_fetch_min(volatile __local atomic_intptr_t *, uintptr_t);
+long __ovld atomic_fetch_max(volatile __global atomic_long *, long);
+long __ovld atomic_fetch_max(volatile __local atomic_long *, long);
+ulong __ovld atomic_fetch_max(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_fetch_max(volatile __local atomic_ulong *, ulong);
+uintptr_t __ovld atomic_fetch_max(volatile __global atomic_uintptr_t *, uintptr_t);
+uintptr_t __ovld atomic_fetch_max(volatile __local atomic_uintptr_t *, uintptr_t);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_fetch_add_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_sub_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_or_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_xor_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_and_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_min_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_max_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *, uint, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+long __ovld atomic_fetch_add_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *, ulong, memory_order);
+long __ovld atomic_fetch_sub_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *, ulong, memory_order);
+long __ovld atomic_fetch_or_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *, ulong, memory_order);
+long __ovld atomic_fetch_xor_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *, ulong, memory_order);
+long __ovld atomic_fetch_and_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *, ulong, memory_order);
+long __ovld atomic_fetch_min_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *, ulong, memory_order);
+long __ovld atomic_fetch_max_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order);
+uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_fetch_add_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_add_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_add_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_add_explicit(volatile __local atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_sub_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_sub_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_sub_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_sub_explicit(volatile __local atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_or_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_or_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_or_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_or_explicit(volatile __local atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_xor_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_xor_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_xor_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_xor_explicit(volatile __local atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_and_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_and_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_and_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_and_explicit(volatile __local atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_min_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_min_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_min_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_min_explicit(volatile __local atomic_uint *, uint, memory_order);
+int __ovld atomic_fetch_max_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_fetch_max_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_fetch_max_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_fetch_max_explicit(volatile __local atomic_uint *, uint, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+long __ovld atomic_fetch_add_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_add_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_add_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_add_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_add_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order);
+uintptr_t __ovld atomic_fetch_add_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order);
+long __ovld atomic_fetch_sub_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_sub_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_sub_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_sub_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_sub_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order);
+uintptr_t __ovld atomic_fetch_sub_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order);
+long __ovld atomic_fetch_or_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_or_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_or_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_or_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order);
+uintptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order);
+intptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order);
+intptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order);
+long __ovld atomic_fetch_xor_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_xor_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_xor_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_xor_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order);
+uintptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order);
+intptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order);
+intptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order);
+long __ovld atomic_fetch_and_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_and_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_and_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_and_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order);
+uintptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order);
+intptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order);
+intptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order);
+long __ovld atomic_fetch_min_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_min_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_min_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_min_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order);
+uintptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order);
+intptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order);
+intptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order);
+long __ovld atomic_fetch_max_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_fetch_max_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_fetch_max_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_fetch_max_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+uintptr_t __ovld atomic_fetch_max_explicit(volatile __global atomic_uintptr_t *, uintptr_t, memory_order);
+uintptr_t __ovld atomic_fetch_max_explicit(volatile __local atomic_uintptr_t *, uintptr_t, memory_order);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_fetch_add_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_sub_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_or_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_xor_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_and_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_min_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_max_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+long __ovld atomic_fetch_add_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_sub_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_or_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_xor_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_and_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_min_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_max_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_fetch_add_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_add_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_add_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_add_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_sub_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_sub_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_sub_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_sub_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_or_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_or_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_or_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_or_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_xor_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_xor_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_xor_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_xor_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_and_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_and_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_and_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_and_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_min_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_min_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_min_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_min_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+int __ovld atomic_fetch_max_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_fetch_max_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_fetch_max_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_fetch_max_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+long __ovld atomic_fetch_add_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_add_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_add_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_add_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope);
+ulong __ovld atomic_fetch_add_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_add_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+long __ovld atomic_fetch_sub_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_sub_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_sub_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_sub_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_sub_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_sub_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope);
+long __ovld atomic_fetch_or_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_or_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_or_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_or_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+long __ovld atomic_fetch_xor_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_xor_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_xor_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_xor_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+long __ovld atomic_fetch_and_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_and_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_and_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_and_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+long __ovld atomic_fetch_min_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_min_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_min_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_min_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+intptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope);
+long __ovld atomic_fetch_max_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_fetch_max_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_fetch_max_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_fetch_max_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_max_explicit(volatile __global atomic_uintptr_t *, uintptr_t, memory_order, memory_scope);
+uintptr_t __ovld atomic_fetch_max_explicit(volatile __local atomic_uintptr_t *, uintptr_t, memory_order, memory_scope);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+
+// The functionality added by cl_ext_float_atomics extension
+#if defined(cl_ext_float_atomics)
+
+#if defined(__opencl_c_ext_fp16_global_atomic_load_store)
+void __ovld atomic_store(volatile __global atomic_half *, half);
+void __ovld atomic_store_explicit(volatile __global atomic_half *,
+                                  half, memory_order);
+void __ovld atomic_store_explicit(volatile __global atomic_half *,
+                                  half, memory_order, memory_scope);
+half __ovld atomic_load(volatile __global atomic_half *);
+half __ovld atomic_load_explicit(volatile __global atomic_half *,
+                                 memory_order);
+half __ovld atomic_load_explicit(volatile __global atomic_half *,
+                                 memory_order, memory_scope);
+half __ovld atomic_exchange(volatile __global atomic_half *, half);
+half __ovld atomic_exchange_explicit(volatile __global atomic_half *,
+                                     half, memory_order);
+half __ovld atomic_exchange_explicit(volatile __global atomic_half *,
+                                     half, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_global_atomic_load_store)
+
+#if defined(__opencl_c_ext_fp16_local_atomic_load_store)
+void __ovld atomic_store(volatile __local atomic_half *, half);
+void __ovld atomic_store_explicit(volatile __local atomic_half *,
+                                  half, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_half *,
+                                  half, memory_order, memory_scope);
+half __ovld atomic_load(volatile __local atomic_half *);
+half __ovld atomic_load_explicit(volatile __local atomic_half *,
+                                 memory_order);
+half __ovld atomic_load_explicit(volatile __local atomic_half *,
+                                 memory_order, memory_scope);
+half __ovld atomic_exchange(volatile __local atomic_half *, half);
+half __ovld atomic_exchange_explicit(volatile __local atomic_half *,
+                                     half, memory_order);
+half __ovld atomic_exchange_explicit(volatile __local atomic_half *,
+                                     half, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_local_atomic_load_store)
+
+#if defined(__opencl_c_ext_fp16_global_atomic_load_store) &&                   \
+    defined(__opencl_c_ext_fp16_local_atomic_load_store)
+void __ovld atomic_store(volatile atomic_half *, half);
+void __ovld atomic_store_explicit(volatile atomic_half *, half,
+                                  memory_order);
+void __ovld atomic_store_explicit(volatile atomic_half *, half,
+                                  memory_order, memory_scope);
+half __ovld atomic_load(volatile atomic_half *);
+half __ovld atomic_load_explicit(volatile atomic_half *,
+                                 memory_order);
+half __ovld atomic_load_explicit(volatile atomic_half *,
+                                 memory_order, memory_scope);
+half __ovld atomic_exchange(volatile atomic_half *, half);
+half __ovld atomic_exchange_explicit(volatile atomic_half *, half,
+                                     memory_order);
+half __ovld atomic_exchange_explicit(volatile atomic_half *, half,
+                                     memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_global_atomic_load_store) &&
+       // defined(__opencl_c_ext_fp16_local_atomic_load_store)
+
+#if defined(__opencl_c_ext_fp16_global_atomic_min_max)
+half __ovld atomic_fetch_min(volatile __global atomic_half *, half);
+half __ovld atomic_fetch_max(volatile __global atomic_half *, half);
+half __ovld atomic_fetch_min_explicit(volatile __global atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_max_explicit(volatile __global atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_min_explicit(volatile __global atomic_half *,
+                                      half, memory_order, memory_scope);
+half __ovld atomic_fetch_max_explicit(volatile __global atomic_half *,
+                                      half, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_global_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp16_local_atomic_min_max)
+half __ovld atomic_fetch_min(volatile __local atomic_half *, half);
+half __ovld atomic_fetch_max(volatile __local atomic_half *, half);
+half __ovld atomic_fetch_min_explicit(volatile __local atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_max_explicit(volatile __local atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_min_explicit(volatile __local atomic_half *,
+                                      half, memory_order, memory_scope);
+half __ovld atomic_fetch_max_explicit(volatile __local atomic_half *,
+                                      half, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_local_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp16_global_atomic_min_max) &&                      \
+    defined(__opencl_c_ext_fp16_local_atomic_min_max)
+half __ovld atomic_fetch_min(volatile atomic_half *, half);
+half __ovld atomic_fetch_max(volatile atomic_half *, half);
+half __ovld atomic_fetch_min_explicit(volatile atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_max_explicit(volatile atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_min_explicit(volatile atomic_half *,
+                                      half, memory_order, memory_scope);
+half __ovld atomic_fetch_max_explicit(volatile atomic_half *,
+                                      half, memory_order, memory_scope);
+#endif
+// defined(__opencl_c_ext_fp16_global_atomic_min_max) &&  \
+//    defined(__opencl_c_ext_fp16_local_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp32_global_atomic_min_max)
+float __ovld atomic_fetch_min(volatile __global atomic_float *, float);
+float __ovld atomic_fetch_max(volatile __global atomic_float *, float);
+float __ovld atomic_fetch_min_explicit(volatile __global atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_max_explicit(volatile __global atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_min_explicit(volatile __global atomic_float *,
+                                       float, memory_order, memory_scope);
+float __ovld atomic_fetch_max_explicit(volatile __global atomic_float *,
+                                       float, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp32_global_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp32_local_atomic_min_max)
+float __ovld atomic_fetch_min(volatile __local atomic_float *, float);
+float __ovld atomic_fetch_max(volatile __local atomic_float *, float);
+float __ovld atomic_fetch_min_explicit(volatile __local atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_max_explicit(volatile __local atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_min_explicit(volatile __local atomic_float *,
+                                       float, memory_order, memory_scope);
+float __ovld atomic_fetch_max_explicit(volatile __local atomic_float *,
+                                       float, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp32_local_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp32_global_atomic_min_max) &&                      \
+    defined(__opencl_c_ext_fp32_local_atomic_min_max)
+float __ovld atomic_fetch_min(volatile atomic_float *, float);
+float __ovld atomic_fetch_max(volatile atomic_float *, float);
+float __ovld atomic_fetch_min_explicit(volatile atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_max_explicit(volatile atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_min_explicit(volatile atomic_float *,
+                                       float, memory_order, memory_scope);
+float __ovld atomic_fetch_max_explicit(volatile atomic_float *,
+                                       float, memory_order, memory_scope);
+#endif
+// defined(__opencl_c_ext_fp32_global_atomic_min_max) &&
+//    defined(__opencl_c_ext_fp32_local_atomic_min_max)
+
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#if defined(__opencl_c_ext_fp64_global_atomic_min_max)
+double __ovld atomic_fetch_min(volatile __global atomic_double *, double);
+double __ovld atomic_fetch_max(volatile __global atomic_double *, double);
+double __ovld atomic_fetch_min_explicit(volatile __global atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_max_explicit(volatile __global atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_min_explicit(volatile __global atomic_double *,
+                                        double, memory_order, memory_scope);
+double __ovld atomic_fetch_max_explicit(volatile __global atomic_double *,
+                                        double, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp64_global_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp64_local_atomic_min_max)
+double __ovld atomic_fetch_min(volatile __local atomic_double *, double);
+double __ovld atomic_fetch_max(volatile __local atomic_double *, double);
+double __ovld atomic_fetch_min_explicit(volatile __local atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_max_explicit(volatile __local atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_min_explicit(volatile __local atomic_double *,
+                                        double, memory_order, memory_scope);
+double __ovld atomic_fetch_max_explicit(volatile __local atomic_double *,
+                                        double, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp64_local_atomic_min_max)
+
+#if defined(__opencl_c_ext_fp64_global_atomic_min_max) &&                      \
+    defined(__opencl_c_ext_fp64_local_atomic_min_max)
+double __ovld atomic_fetch_min(volatile atomic_double *, double);
+double __ovld atomic_fetch_max(volatile atomic_double *, double);
+double __ovld atomic_fetch_min_explicit(volatile atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_max_explicit(volatile atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_min_explicit(volatile atomic_double *,
+                                        double, memory_order, memory_scope);
+double __ovld atomic_fetch_max_explicit(volatile atomic_double *,
+                                        double, memory_order, memory_scope);
+#endif
+/* defined(__opencl_c_ext_fp64_global_atomic_min_max) &&
+   defined(__opencl_c_ext_fp64_local_atomic_min_max) */
+
+#endif
+/* defined(cl_khr_int64_base_atomics) &&
+   defined(cl_khr_int64_extended_atomics) */
+
+#if defined(__opencl_c_ext_fp16_global_atomic_add)
+half __ovld atomic_fetch_add(volatile __global atomic_half *, half);
+half __ovld atomic_fetch_sub(volatile __global atomic_half *, half);
+half __ovld atomic_fetch_add_explicit(volatile __global atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_sub_explicit(volatile __global atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_add_explicit(volatile __global atomic_half *,
+                                      half, memory_order, memory_scope);
+half __ovld atomic_fetch_sub_explicit(volatile __global atomic_half *,
+                                      half, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_global_atomic_add)
+
+#if defined(__opencl_c_ext_fp16_local_atomic_add)
+half __ovld atomic_fetch_add(volatile __local atomic_half *, half);
+half __ovld atomic_fetch_sub(volatile __local atomic_half *, half);
+half __ovld atomic_fetch_add_explicit(volatile __local atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_sub_explicit(volatile __local atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_add_explicit(volatile __local atomic_half *,
+                                      half, memory_order, memory_scope);
+half __ovld atomic_fetch_sub_explicit(volatile __local atomic_half *,
+                                      half, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp16_local_atomic_add)
+
+#if defined(__opencl_c_ext_fp16_global_atomic_add) &&                          \
+    defined(__opencl_c_ext_fp16_local_atomic_add)
+half __ovld atomic_fetch_add(volatile atomic_half *, half);
+half __ovld atomic_fetch_sub(volatile atomic_half *, half);
+half __ovld atomic_fetch_add_explicit(volatile atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_sub_explicit(volatile atomic_half *,
+                                      half, memory_order);
+half __ovld atomic_fetch_add_explicit(volatile atomic_half *,
+                                      half, memory_order, memory_scope);
+half __ovld atomic_fetch_sub_explicit(volatile atomic_half *,
+                                      half, memory_order, memory_scope);
+#endif
+
+/* defined(__opencl_c_ext_fp16_global_atomic_add) &&
+   defined(__opencl_c_ext_fp16_local_atomic_add) */
+
+#if defined(__opencl_c_ext_fp32_global_atomic_add)
+float __ovld atomic_fetch_add(volatile __global atomic_float *, float);
+float __ovld atomic_fetch_sub(volatile __global atomic_float *, float);
+float __ovld atomic_fetch_add_explicit(volatile __global atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_sub_explicit(volatile __global atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_add_explicit(volatile __global atomic_float *,
+                                       float, memory_order, memory_scope);
+float __ovld atomic_fetch_sub_explicit(volatile __global atomic_float *,
+                                       float, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp32_global_atomic_add)
+
+#if defined(__opencl_c_ext_fp32_local_atomic_add)
+float __ovld atomic_fetch_add(volatile __local atomic_float *, float);
+float __ovld atomic_fetch_sub(volatile __local atomic_float *, float);
+float __ovld atomic_fetch_add_explicit(volatile __local atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_sub_explicit(volatile __local atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_add_explicit(volatile __local atomic_float *,
+                                       float, memory_order, memory_scope);
+float __ovld atomic_fetch_sub_explicit(volatile __local atomic_float *,
+                                       float, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp32_local_atomic_add)
+
+#if defined(__opencl_c_ext_fp32_global_atomic_add) &&                          \
+    defined(__opencl_c_ext_fp32_local_atomic_add)
+float __ovld atomic_fetch_add(volatile atomic_float *, float);
+float __ovld atomic_fetch_sub(volatile atomic_float *, float);
+float __ovld atomic_fetch_add_explicit(volatile atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_sub_explicit(volatile atomic_float *,
+                                       float, memory_order);
+float __ovld atomic_fetch_add_explicit(volatile atomic_float *,
+                                       float, memory_order, memory_scope);
+float __ovld atomic_fetch_sub_explicit(volatile atomic_float *,
+                                       float, memory_order, memory_scope);
+#endif
+
+/* defined(__opencl_c_ext_fp32_global_atomic_add) &&
+   defined(__opencl_c_ext_fp32_local_atomic_add) */
+
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#if defined(__opencl_c_ext_fp64_global_atomic_add)
+double __ovld atomic_fetch_add(volatile __global atomic_double *, double);
+double __ovld atomic_fetch_sub(volatile __global atomic_double *, double);
+double __ovld atomic_fetch_add_explicit(volatile __global atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_sub_explicit(volatile __global atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_add_explicit(volatile __global atomic_double *,
+                                        double, memory_order, memory_scope);
+double __ovld atomic_fetch_sub_explicit(volatile __global atomic_double *,
+                                        double, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp64_global_atomic_add)
+
+#if defined(__opencl_c_ext_fp64_local_atomic_add)
+double __ovld atomic_fetch_add(volatile __local atomic_double *, double);
+double __ovld atomic_fetch_sub(volatile __local atomic_double *, double);
+double __ovld atomic_fetch_add_explicit(volatile __local atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_sub_explicit(volatile __local atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_add_explicit(volatile __local atomic_double *,
+                                        double, memory_order, memory_scope);
+double __ovld atomic_fetch_sub_explicit(volatile __local atomic_double *,
+                                        double, memory_order, memory_scope);
+#endif // defined(__opencl_c_ext_fp64_local_atomic_add)
+
+#if defined(__opencl_c_ext_fp64_global_atomic_add) &&                          \
+    defined(__opencl_c_ext_fp64_local_atomic_add)
+double __ovld atomic_fetch_add(volatile atomic_double *, double);
+double __ovld atomic_fetch_sub(volatile atomic_double *, double);
+double __ovld atomic_fetch_add_explicit(volatile atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_sub_explicit(volatile atomic_double *,
+                                        double, memory_order);
+double __ovld atomic_fetch_add_explicit(volatile atomic_double *,
+                                        double, memory_order, memory_scope);
+double __ovld atomic_fetch_sub_explicit(volatile atomic_double *,
+                                        double, memory_order, memory_scope);
+#endif
+
+/* defined(__opencl_c_ext_fp64_global_atomic_add) &&
+   defined(__opencl_c_ext_fp64_local_atomic_add) */
+
+#endif
+
+/* defined(cl_khr_int64_base_atomics) &&
+   defined(cl_khr_int64_extended_atomics) */
+
+#endif // cl_ext_float_atomics
+
+// atomic_store()
+
+#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+void __ovld atomic_store(volatile atomic_int *, int);
+void __ovld atomic_store(volatile atomic_uint *, uint);
+void __ovld atomic_store(volatile atomic_float *, float);
+
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+void __ovld atomic_store(volatile atomic_double *, double);
+#endif //cl_khr_fp64
+void __ovld atomic_store(volatile atomic_long *, long);
+void __ovld atomic_store(volatile atomic_ulong *, ulong);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+void __ovld atomic_store(volatile __global atomic_int *, int);
+void __ovld atomic_store(volatile __local atomic_int *, int);
+void __ovld atomic_store(volatile __global atomic_uint *, uint);
+void __ovld atomic_store(volatile __local atomic_uint *, uint);
+void __ovld atomic_store(volatile __global atomic_float *, float);
+void __ovld atomic_store(volatile __local atomic_float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+void __ovld atomic_store(volatile __global atomic_double *, double);
+void __ovld atomic_store(volatile __local atomic_double *, double);
+#endif //cl_khr_fp64
+void __ovld atomic_store(volatile __global atomic_long *, long);
+void __ovld atomic_store(volatile __local atomic_long *, long);
+void __ovld atomic_store(volatile __global atomic_ulong *, ulong);
+void __ovld atomic_store(volatile __local atomic_ulong *, ulong);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+void __ovld atomic_store_explicit(volatile atomic_int *, int, memory_order);
+void __ovld atomic_store_explicit(volatile atomic_uint *, uint, memory_order);
+void __ovld atomic_store_explicit(volatile atomic_float *, float, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+void __ovld atomic_store_explicit(volatile atomic_double *, double, memory_order);
+#endif //cl_khr_fp64
+void __ovld atomic_store_explicit(volatile atomic_long *, long, memory_order);
+void __ovld atomic_store_explicit(volatile atomic_ulong *, ulong, memory_order);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+void __ovld atomic_store_explicit(volatile __global atomic_int *, int, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_int *, int, memory_order);
+void __ovld atomic_store_explicit(volatile __global atomic_uint *, uint, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_uint *, uint, memory_order);
+void __ovld atomic_store_explicit(volatile __global atomic_float *, float, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_float *, float, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+void __ovld atomic_store_explicit(volatile __global atomic_double *, double, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_double *, double, memory_order);
+#endif
+void __ovld atomic_store_explicit(volatile __global atomic_long *, long, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_long *, long, memory_order);
+void __ovld atomic_store_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+void __ovld atomic_store_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_generic_address_space)
+void __ovld atomic_store_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile atomic_float *, float, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+void __ovld atomic_store_explicit(volatile atomic_double *, double, memory_order, memory_scope);
+#endif //cl_khr_fp64
+void __ovld atomic_store_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+void __ovld atomic_store_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __global atomic_float *, float, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __local atomic_float *, float, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+void __ovld atomic_store_explicit(volatile __global atomic_double *, double, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __local atomic_double *, double, memory_order, memory_scope);
+#endif //cl_khr_fp64
+void __ovld atomic_store_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+void __ovld atomic_store_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+
+// atomic_load()
+#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_load(volatile atomic_int *);
+uint __ovld atomic_load(volatile atomic_uint *);
+float __ovld atomic_load(volatile atomic_float *);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_load(volatile atomic_double *);
+#endif //cl_khr_fp64
+long __ovld atomic_load(volatile atomic_long *);
+ulong __ovld atomic_load(volatile atomic_ulong *);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_load(volatile __global atomic_int *);
+int __ovld atomic_load(volatile __local atomic_int *);
+uint __ovld atomic_load(volatile __global atomic_uint *);
+uint __ovld atomic_load(volatile __local atomic_uint *);
+float __ovld atomic_load(volatile __global atomic_float *);
+float __ovld atomic_load(volatile __local atomic_float *);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_load(volatile __global atomic_double *);
+double __ovld atomic_load(volatile __local atomic_double *);
+#endif //cl_khr_fp64
+long __ovld atomic_load(volatile __global atomic_long *);
+long __ovld atomic_load(volatile __local atomic_long *);
+ulong __ovld atomic_load(volatile __global atomic_ulong *);
+ulong __ovld atomic_load(volatile __local atomic_ulong *);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_load_explicit(volatile atomic_int *, memory_order);
+uint __ovld atomic_load_explicit(volatile atomic_uint *, memory_order);
+float __ovld atomic_load_explicit(volatile atomic_float *, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_load_explicit(volatile atomic_double *, memory_order);
+#endif //cl_khr_fp64
+long __ovld atomic_load_explicit(volatile atomic_long *, memory_order);
+ulong __ovld atomic_load_explicit(volatile atomic_ulong *, memory_order);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_load_explicit(volatile __global atomic_int *, memory_order);
+int __ovld atomic_load_explicit(volatile __local atomic_int *, memory_order);
+uint __ovld atomic_load_explicit(volatile __global atomic_uint *, memory_order);
+uint __ovld atomic_load_explicit(volatile __local atomic_uint *, memory_order);
+float __ovld atomic_load_explicit(volatile __global atomic_float *, memory_order);
+float __ovld atomic_load_explicit(volatile __local atomic_float *, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_load_explicit(volatile __global atomic_double *, memory_order);
+double __ovld atomic_load_explicit(volatile __local atomic_double *, memory_order);
+#endif //cl_khr_fp64
+long __ovld atomic_load_explicit(volatile __global atomic_long *, memory_order);
+long __ovld atomic_load_explicit(volatile __local atomic_long *, memory_order);
+ulong __ovld atomic_load_explicit(volatile __global atomic_ulong *, memory_order);
+ulong __ovld atomic_load_explicit(volatile __local atomic_ulong *, memory_order);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_load_explicit(volatile atomic_int *, memory_order, memory_scope);
+uint __ovld atomic_load_explicit(volatile atomic_uint *, memory_order, memory_scope);
+float __ovld atomic_load_explicit(volatile atomic_float *, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_load_explicit(volatile atomic_double *, memory_order, memory_scope);
+#endif //cl_khr_fp64
+long __ovld atomic_load_explicit(volatile atomic_long *, memory_order, memory_scope);
+ulong __ovld atomic_load_explicit(volatile atomic_ulong *, memory_order, memory_scope);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_load_explicit(volatile __global atomic_int *, memory_order, memory_scope);
+int __ovld atomic_load_explicit(volatile __local atomic_int *, memory_order, memory_scope);
+uint __ovld atomic_load_explicit(volatile __global atomic_uint *, memory_order, memory_scope);
+uint __ovld atomic_load_explicit(volatile __local atomic_uint *, memory_order, memory_scope);
+float __ovld atomic_load_explicit(volatile __global atomic_float *, memory_order, memory_scope);
+float __ovld atomic_load_explicit(volatile __local atomic_float *, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_load_explicit(volatile __global atomic_double *, memory_order, memory_scope);
+double __ovld atomic_load_explicit(volatile __local atomic_double *, memory_order, memory_scope);
+#endif
+long __ovld atomic_load_explicit(volatile __global atomic_long *, memory_order, memory_scope);
+long __ovld atomic_load_explicit(volatile __local atomic_long *, memory_order, memory_scope);
+ulong __ovld atomic_load_explicit(volatile __global atomic_ulong *, memory_order, memory_scope);
+ulong __ovld atomic_load_explicit(volatile __local atomic_ulong *, memory_order, memory_scope);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+
+// atomic_exchange()
+
+#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_exchange(volatile atomic_int *, int);
+uint __ovld atomic_exchange(volatile atomic_uint *, uint);
+float __ovld atomic_exchange(volatile atomic_float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_exchange(volatile atomic_double *, double);
+#endif //cl_khr_fp64
+long __ovld atomic_exchange(volatile atomic_long *, long);
+ulong __ovld atomic_exchange(volatile atomic_ulong *, ulong);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_exchange(volatile __global atomic_int *, int);
+int __ovld atomic_exchange(volatile __local atomic_int *, int);
+uint __ovld atomic_exchange(volatile __global atomic_uint *, uint);
+uint __ovld atomic_exchange(volatile __local atomic_uint *, uint);
+float __ovld atomic_exchange(volatile __global atomic_float *, float);
+float __ovld atomic_exchange(volatile __local atomic_float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_exchange(volatile __global atomic_double *, double);
+double __ovld atomic_exchange(volatile __local atomic_double *, double);
+#endif //cl_khr_fp64
+long __ovld atomic_exchange(volatile __global atomic_long *, long);
+long __ovld atomic_exchange(volatile __local atomic_long *, long);
+ulong __ovld atomic_exchange(volatile __global atomic_ulong *, ulong);
+ulong __ovld atomic_exchange(volatile __local atomic_ulong *, ulong);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_exchange_explicit(volatile atomic_int *, int, memory_order);
+uint __ovld atomic_exchange_explicit(volatile atomic_uint *, uint, memory_order);
+float __ovld atomic_exchange_explicit(volatile atomic_float *, float, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_exchange_explicit(volatile atomic_double *, double, memory_order);
+#endif //cl_khr_fp64
+long __ovld atomic_exchange_explicit(volatile atomic_long *, long, memory_order);
+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *, ulong, memory_order);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_exchange_explicit(volatile __global atomic_int *, int, memory_order);
+int __ovld atomic_exchange_explicit(volatile __local atomic_int *, int, memory_order);
+uint __ovld atomic_exchange_explicit(volatile __global atomic_uint *, uint, memory_order);
+uint __ovld atomic_exchange_explicit(volatile __local atomic_uint *, uint, memory_order);
+float __ovld atomic_exchange_explicit(volatile __global atomic_float *, float, memory_order);
+float __ovld atomic_exchange_explicit(volatile __local atomic_float *, float, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_exchange_explicit(volatile __global atomic_double *, double, memory_order);
+double __ovld atomic_exchange_explicit(volatile __local atomic_double *, double, memory_order);
+#endif //cl_khr_fp64
+long __ovld atomic_exchange_explicit(volatile __global atomic_long *, long, memory_order);
+long __ovld atomic_exchange_explicit(volatile __local atomic_long *, long, memory_order);
+ulong __ovld atomic_exchange_explicit(volatile __global atomic_ulong *, ulong, memory_order);
+ulong __ovld atomic_exchange_explicit(volatile __local atomic_ulong *, ulong, memory_order);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)wi
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_generic_address_space)
+int __ovld atomic_exchange_explicit(volatile atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_exchange_explicit(volatile atomic_uint *, uint, memory_order, memory_scope);
+float __ovld atomic_exchange_explicit(volatile atomic_float *, float, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_exchange_explicit(volatile atomic_double *, double, memory_order, memory_scope);
+#endif //cl_khr_fp64
+long __ovld atomic_exchange_explicit(volatile atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+int __ovld atomic_exchange_explicit(volatile __global atomic_int *, int, memory_order, memory_scope);
+int __ovld atomic_exchange_explicit(volatile __local atomic_int *, int, memory_order, memory_scope);
+uint __ovld atomic_exchange_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope);
+uint __ovld atomic_exchange_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope);
+float __ovld atomic_exchange_explicit(volatile __global atomic_float *, float, memory_order, memory_scope);
+float __ovld atomic_exchange_explicit(volatile __local atomic_float *, float, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+double __ovld atomic_exchange_explicit(volatile __global atomic_double *, double, memory_order, memory_scope);
+double __ovld atomic_exchange_explicit(volatile __local atomic_double *, double, memory_order, memory_scope);
+#endif //cl_khr_fp64
+long __ovld atomic_exchange_explicit(volatile __global atomic_long *, long, memory_order, memory_scope);
+long __ovld atomic_exchange_explicit(volatile __local atomic_long *, long, memory_order, memory_scope);
+ulong __ovld atomic_exchange_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope);
+ulong __ovld atomic_exchange_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+
+// atomic_compare_exchange_strong() and atomic_compare_exchange_weak()
+#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+bool __ovld atomic_compare_exchange_strong(volatile atomic_int *, int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *, uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile atomic_int *, int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *, uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile atomic_float *, float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile atomic_float *, float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong(volatile atomic_double *, double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile atomic_double *, double *, double);
+#endif //cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong(volatile atomic_long *, long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile atomic_long *, long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *, ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *, ulong *, ulong);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_int *, __global int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_int *, __local int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_int *, __private int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_int *, __global int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_int *, __local int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_int *, __private int *, int);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_uint *, __global uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_uint *, __local uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_uint *, __private uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_uint *, __global uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_uint *, __local uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_uint *, __private uint *, uint);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_float *, __global float *, float);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_float *, __local float *, float);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_float *, __private float *, float);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_float *, __global float *, float);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_float *, __local float *, float);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_float *, __private float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_int *, __global int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_int *, __local int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_int *, __private int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_int *, __global int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_int *, __local int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_int *, __private int *, int);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_uint *, __global uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_uint *, __local uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_uint *, __private uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_uint *, __global uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_uint *, __local uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_uint *, __private uint *, uint);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_float *, __global float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_float *, __local float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_float *, __private float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_float *, __global float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_float *, __local float *, float);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_float *, __private float *, float);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_double *, __global double *, double);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_double *, __local double *, double);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_double *, __private double *, double);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_double *, __global double *, double);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_double *, __local double *, double);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_double *, __private double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_double *, __global double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_double *, __local double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_double *, __private double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_double *, __global double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_double *, __local double *, double);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_double *, __private double *, double);
+#endif //cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_long *, __global long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_long *, __local long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_long *, __private long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_long *, __global long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_long *, __local long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_long *, __private long *, long);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_ulong *, __global ulong *, ulong);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_ulong *, __local ulong *, ulong);
+bool __ovld atomic_compare_exchange_strong(volatile __global atomic_ulong *, __private ulong *, ulong);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_ulong *, __global ulong *, ulong);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_ulong *, __local ulong *, ulong);
+bool __ovld atomic_compare_exchange_strong(volatile __local atomic_ulong *, __private ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_long *, __global long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_long *, __local long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_long *, __private long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_long *, __global long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_long *, __local long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_long *, __private long *, long);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_ulong *, __global ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_ulong *, __local ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile __global atomic_ulong *, __private ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_ulong *, __global ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_ulong *, __local ulong *, ulong);
+bool __ovld atomic_compare_exchange_weak(volatile __local atomic_ulong *, __private ulong *, ulong);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *, int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *, int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *, float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *, float *, float, memory_order, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *, double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *, double *, double, memory_order, memory_order);
+#endif //cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *, long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *, long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order);
+#endif //cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif //defined(__opencl_c_atomic_scope_device)
+
+#if defined(__opencl_c_generic_address_space)
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *, int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *, int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *, float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *, float *, float, memory_order, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *, double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *, double *, double, memory_order, memory_order, memory_scope);
+#endif //cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *, long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *, long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order, memory_scope);
+#endif
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order, memory_scope);
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#ifdef cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order, memory_scope);
+#endif //cl_khr_fp64
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope);
+bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope);
+#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+
+// atomic_flag_test_and_set() and atomic_flag_clear()
+#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+bool __ovld atomic_flag_test_and_set(volatile atomic_flag *);
+void __ovld atomic_flag_clear(volatile atomic_flag *);
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+bool __ovld atomic_flag_test_and_set(volatile __global atomic_flag *);
+bool __ovld atomic_flag_test_and_set(volatile __local atomic_flag *);
+void __ovld atomic_flag_clear(volatile __global atomic_flag *);
+void __ovld atomic_flag_clear(volatile __local atomic_flag *);
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_atomic_scope_device)
+#if defined(__opencl_c_generic_address_space)
+bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order);
+void __ovld atomic_flag_clear_explicit(volatile atomic_flag *, memory_order);
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+bool __ovld atomic_flag_test_and_set_explicit(volatile __global atomic_flag *, memory_order);
+bool __ovld atomic_flag_test_and_set_explicit(volatile __local atomic_flag *, memory_order);
+void __ovld atomic_flag_clear_explicit(volatile __global atomic_flag *, memory_order);
+void __ovld atomic_flag_clear_explicit(volatile __local atomic_flag *, memory_order);
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif
+
+#if defined(__opencl_c_generic_address_space)
+bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order, memory_scope);
+void __ovld atomic_flag_clear_explicit(volatile atomic_flag *, memory_order, memory_scope);
+#endif //defined(__opencl_c_generic_address_space)
+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+bool __ovld atomic_flag_test_and_set_explicit(volatile __global atomic_flag *, memory_order, memory_scope);
+bool __ovld atomic_flag_test_and_set_explicit(volatile __local atomic_flag *, memory_order, memory_scope);
+void __ovld atomic_flag_clear_explicit(volatile __global atomic_flag *, memory_order, memory_scope);
+void __ovld atomic_flag_clear_explicit(volatile __local atomic_flag *, memory_order, memory_scope);
+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100)
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions
+
+/**
+ * The shuffle and shuffle2 built-in functions construct
+ * a permutation of elements from one or two input
+ * vectors respectively that are of the same type,
+ * returning a vector with the same element type as the
+ * input and length that is the same as the shuffle mask.
+ * The size of each element in the mask must match the
+ * size of each element in the result. For shuffle, only
+ * the ilogb(2m-1) least significant bits of each mask
+ * element are considered. For shuffle2, only the
+ * ilogb(2m-1)+1 least significant bits of each mask
+ * element are considered. Other bits in the mask shall
+ * be ignored.
+ * The elements of the input vectors are numbered from
+ * left to right across one or both of the vectors. For this
+ * purpose, the number of elements in a vector is given
+ * by vec_step(gentypem). The shuffle mask operand
+ * specifies, for each element of the result vector, which
+ * element of the one or two input vectors the result
+ * element gets.
+ * Examples:
+ * uint4 mask = (uint4)(3, 2,
+ * 1, 0);
+ * float4 a;
+ * float4 r = shuffle(a, mask);
+ * // r.s0123 = a.wzyx
+ * uint8 mask = (uint8)(0, 1, 2, 3,
+ * 4, 5, 6, 7);
+ * float4 a, b;
+ * float8 r = shuffle2(a, b, mask);
+ * // r.s0123 = a.xyzw
+ * // r.s4567 = b.xyzw
+ * uint4 mask;
+ * float8 a;
+ * float4 b;
+ * b = shuffle(a, mask);
+ * Examples that are not valid are:
+ * uint8 mask;
+ * short16 a;
+ * short8 b;
+ * b = shuffle(a, mask); <- not valid
+ */
+char2 __ovld __cnfn shuffle(char2, uchar2);
+char2 __ovld __cnfn shuffle(char4, uchar2);
+char2 __ovld __cnfn shuffle(char8, uchar2);
+char2 __ovld __cnfn shuffle(char16, uchar2);
+
+uchar2 __ovld __cnfn shuffle(uchar2, uchar2);
+uchar2 __ovld __cnfn shuffle(uchar4, uchar2);
+uchar2 __ovld __cnfn shuffle(uchar8, uchar2);
+uchar2 __ovld __cnfn shuffle(uchar16, uchar2);
+
+short2 __ovld __cnfn shuffle(short2, ushort2);
+short2 __ovld __cnfn shuffle(short4, ushort2);
+short2 __ovld __cnfn shuffle(short8, ushort2);
+short2 __ovld __cnfn shuffle(short16, ushort2);
+
+ushort2 __ovld __cnfn shuffle(ushort2, ushort2);
+ushort2 __ovld __cnfn shuffle(ushort4, ushort2);
+ushort2 __ovld __cnfn shuffle(ushort8, ushort2);
+ushort2 __ovld __cnfn shuffle(ushort16, ushort2);
+
+int2 __ovld __cnfn shuffle(int2, uint2);
+int2 __ovld __cnfn shuffle(int4, uint2);
+int2 __ovld __cnfn shuffle(int8, uint2);
+int2 __ovld __cnfn shuffle(int16, uint2);
+
+uint2 __ovld __cnfn shuffle(uint2, uint2);
+uint2 __ovld __cnfn shuffle(uint4, uint2);
+uint2 __ovld __cnfn shuffle(uint8, uint2);
+uint2 __ovld __cnfn shuffle(uint16, uint2);
+
+long2 __ovld __cnfn shuffle(long2, ulong2);
+long2 __ovld __cnfn shuffle(long4, ulong2);
+long2 __ovld __cnfn shuffle(long8, ulong2);
+long2 __ovld __cnfn shuffle(long16, ulong2);
+
+ulong2 __ovld __cnfn shuffle(ulong2, ulong2);
+ulong2 __ovld __cnfn shuffle(ulong4, ulong2);
+ulong2 __ovld __cnfn shuffle(ulong8, ulong2);
+ulong2 __ovld __cnfn shuffle(ulong16, ulong2);
+
+float2 __ovld __cnfn shuffle(float2, uint2);
+float2 __ovld __cnfn shuffle(float4, uint2);
+float2 __ovld __cnfn shuffle(float8, uint2);
+float2 __ovld __cnfn shuffle(float16, uint2);
+
+char4 __ovld __cnfn shuffle(char2, uchar4);
+char4 __ovld __cnfn shuffle(char4, uchar4);
+char4 __ovld __cnfn shuffle(char8, uchar4);
+char4 __ovld __cnfn shuffle(char16, uchar4);
+
+uchar4 __ovld __cnfn shuffle(uchar2, uchar4);
+uchar4 __ovld __cnfn shuffle(uchar4, uchar4);
+uchar4 __ovld __cnfn shuffle(uchar8, uchar4);
+uchar4 __ovld __cnfn shuffle(uchar16, uchar4);
+
+short4 __ovld __cnfn shuffle(short2, ushort4);
+short4 __ovld __cnfn shuffle(short4, ushort4);
+short4 __ovld __cnfn shuffle(short8, ushort4);
+short4 __ovld __cnfn shuffle(short16, ushort4);
+
+ushort4 __ovld __cnfn shuffle(ushort2, ushort4);
+ushort4 __ovld __cnfn shuffle(ushort4, ushort4);
+ushort4 __ovld __cnfn shuffle(ushort8, ushort4);
+ushort4 __ovld __cnfn shuffle(ushort16, ushort4);
+
+int4 __ovld __cnfn shuffle(int2, uint4);
+int4 __ovld __cnfn shuffle(int4, uint4);
+int4 __ovld __cnfn shuffle(int8, uint4);
+int4 __ovld __cnfn shuffle(int16, uint4);
+
+uint4 __ovld __cnfn shuffle(uint2, uint4);
+uint4 __ovld __cnfn shuffle(uint4, uint4);
+uint4 __ovld __cnfn shuffle(uint8, uint4);
+uint4 __ovld __cnfn shuffle(uint16, uint4);
+
+long4 __ovld __cnfn shuffle(long2, ulong4);
+long4 __ovld __cnfn shuffle(long4, ulong4);
+long4 __ovld __cnfn shuffle(long8, ulong4);
+long4 __ovld __cnfn shuffle(long16, ulong4);
+
+ulong4 __ovld __cnfn shuffle(ulong2, ulong4);
+ulong4 __ovld __cnfn shuffle(ulong4, ulong4);
+ulong4 __ovld __cnfn shuffle(ulong8, ulong4);
+ulong4 __ovld __cnfn shuffle(ulong16, ulong4);
+
+float4 __ovld __cnfn shuffle(float2, uint4);
+float4 __ovld __cnfn shuffle(float4, uint4);
+float4 __ovld __cnfn shuffle(float8, uint4);
+float4 __ovld __cnfn shuffle(float16, uint4);
+
+char8 __ovld __cnfn shuffle(char2, uchar8);
+char8 __ovld __cnfn shuffle(char4, uchar8);
+char8 __ovld __cnfn shuffle(char8, uchar8);
+char8 __ovld __cnfn shuffle(char16, uchar8);
+
+uchar8 __ovld __cnfn shuffle(uchar2, uchar8);
+uchar8 __ovld __cnfn shuffle(uchar4, uchar8);
+uchar8 __ovld __cnfn shuffle(uchar8, uchar8);
+uchar8 __ovld __cnfn shuffle(uchar16, uchar8);
+
+short8 __ovld __cnfn shuffle(short2, ushort8);
+short8 __ovld __cnfn shuffle(short4, ushort8);
+short8 __ovld __cnfn shuffle(short8, ushort8);
+short8 __ovld __cnfn shuffle(short16, ushort8);
+
+ushort8 __ovld __cnfn shuffle(ushort2, ushort8);
+ushort8 __ovld __cnfn shuffle(ushort4, ushort8);
+ushort8 __ovld __cnfn shuffle(ushort8, ushort8);
+ushort8 __ovld __cnfn shuffle(ushort16, ushort8);
+
+int8 __ovld __cnfn shuffle(int2, uint8);
+int8 __ovld __cnfn shuffle(int4, uint8);
+int8 __ovld __cnfn shuffle(int8, uint8);
+int8 __ovld __cnfn shuffle(int16, uint8);
+
+uint8 __ovld __cnfn shuffle(uint2, uint8);
+uint8 __ovld __cnfn shuffle(uint4, uint8);
+uint8 __ovld __cnfn shuffle(uint8, uint8);
+uint8 __ovld __cnfn shuffle(uint16, uint8);
+
+long8 __ovld __cnfn shuffle(long2, ulong8);
+long8 __ovld __cnfn shuffle(long4, ulong8);
+long8 __ovld __cnfn shuffle(long8, ulong8);
+long8 __ovld __cnfn shuffle(long16, ulong8);
+
+ulong8 __ovld __cnfn shuffle(ulong2, ulong8);
+ulong8 __ovld __cnfn shuffle(ulong4, ulong8);
+ulong8 __ovld __cnfn shuffle(ulong8, ulong8);
+ulong8 __ovld __cnfn shuffle(ulong16, ulong8);
+
+float8 __ovld __cnfn shuffle(float2, uint8);
+float8 __ovld __cnfn shuffle(float4, uint8);
+float8 __ovld __cnfn shuffle(float8, uint8);
+float8 __ovld __cnfn shuffle(float16, uint8);
+
+char16 __ovld __cnfn shuffle(char2, uchar16);
+char16 __ovld __cnfn shuffle(char4, uchar16);
+char16 __ovld __cnfn shuffle(char8, uchar16);
+char16 __ovld __cnfn shuffle(char16, uchar16);
+
+uchar16 __ovld __cnfn shuffle(uchar2, uchar16);
+uchar16 __ovld __cnfn shuffle(uchar4, uchar16);
+uchar16 __ovld __cnfn shuffle(uchar8, uchar16);
+uchar16 __ovld __cnfn shuffle(uchar16, uchar16);
+
+short16 __ovld __cnfn shuffle(short2, ushort16);
+short16 __ovld __cnfn shuffle(short4, ushort16);
+short16 __ovld __cnfn shuffle(short8, ushort16);
+short16 __ovld __cnfn shuffle(short16, ushort16);
+
+ushort16 __ovld __cnfn shuffle(ushort2, ushort16);
+ushort16 __ovld __cnfn shuffle(ushort4, ushort16);
+ushort16 __ovld __cnfn shuffle(ushort8, ushort16);
+ushort16 __ovld __cnfn shuffle(ushort16, ushort16);
+
+int16 __ovld __cnfn shuffle(int2, uint16);
+int16 __ovld __cnfn shuffle(int4, uint16);
+int16 __ovld __cnfn shuffle(int8, uint16);
+int16 __ovld __cnfn shuffle(int16, uint16);
+
+uint16 __ovld __cnfn shuffle(uint2, uint16);
+uint16 __ovld __cnfn shuffle(uint4, uint16);
+uint16 __ovld __cnfn shuffle(uint8, uint16);
+uint16 __ovld __cnfn shuffle(uint16, uint16);
+
+long16 __ovld __cnfn shuffle(long2, ulong16);
+long16 __ovld __cnfn shuffle(long4, ulong16);
+long16 __ovld __cnfn shuffle(long8, ulong16);
+long16 __ovld __cnfn shuffle(long16, ulong16);
+
+ulong16 __ovld __cnfn shuffle(ulong2, ulong16);
+ulong16 __ovld __cnfn shuffle(ulong4, ulong16);
+ulong16 __ovld __cnfn shuffle(ulong8, ulong16);
+ulong16 __ovld __cnfn shuffle(ulong16, ulong16);
+
+float16 __ovld __cnfn shuffle(float2, uint16);
+float16 __ovld __cnfn shuffle(float4, uint16);
+float16 __ovld __cnfn shuffle(float8, uint16);
+float16 __ovld __cnfn shuffle(float16, uint16);
+
+#ifdef cl_khr_fp64
+double2 __ovld __cnfn shuffle(double2, ulong2);
+double2 __ovld __cnfn shuffle(double4, ulong2);
+double2 __ovld __cnfn shuffle(double8, ulong2);
+double2 __ovld __cnfn shuffle(double16, ulong2);
+
+double4 __ovld __cnfn shuffle(double2, ulong4);
+double4 __ovld __cnfn shuffle(double4, ulong4);
+double4 __ovld __cnfn shuffle(double8, ulong4);
+double4 __ovld __cnfn shuffle(double16, ulong4);
+
+double8 __ovld __cnfn shuffle(double2, ulong8);
+double8 __ovld __cnfn shuffle(double4, ulong8);
+double8 __ovld __cnfn shuffle(double8, ulong8);
+double8 __ovld __cnfn shuffle(double16, ulong8);
+
+double16 __ovld __cnfn shuffle(double2, ulong16);
+double16 __ovld __cnfn shuffle(double4, ulong16);
+double16 __ovld __cnfn shuffle(double8, ulong16);
+double16 __ovld __cnfn shuffle(double16, ulong16);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+half2 __ovld __cnfn shuffle(half2, ushort2);
+half2 __ovld __cnfn shuffle(half4, ushort2);
+half2 __ovld __cnfn shuffle(half8, ushort2);
+half2 __ovld __cnfn shuffle(half16, ushort2);
+
+half4 __ovld __cnfn shuffle(half2, ushort4);
+half4 __ovld __cnfn shuffle(half4, ushort4);
+half4 __ovld __cnfn shuffle(half8, ushort4);
+half4 __ovld __cnfn shuffle(half16, ushort4);
+
+half8 __ovld __cnfn shuffle(half2, ushort8);
+half8 __ovld __cnfn shuffle(half4, ushort8);
+half8 __ovld __cnfn shuffle(half8, ushort8);
+half8 __ovld __cnfn shuffle(half16, ushort8);
+
+half16 __ovld __cnfn shuffle(half2, ushort16);
+half16 __ovld __cnfn shuffle(half4, ushort16);
+half16 __ovld __cnfn shuffle(half8, ushort16);
+half16 __ovld __cnfn shuffle(half16, ushort16);
+#endif //cl_khr_fp16
+
+char2 __ovld __cnfn shuffle2(char2, char2, uchar2);
+char2 __ovld __cnfn shuffle2(char4, char4, uchar2);
+char2 __ovld __cnfn shuffle2(char8, char8, uchar2);
+char2 __ovld __cnfn shuffle2(char16, char16, uchar2);
+
+uchar2 __ovld __cnfn shuffle2(uchar2, uchar2, uchar2);
+uchar2 __ovld __cnfn shuffle2(uchar4, uchar4, uchar2);
+uchar2 __ovld __cnfn shuffle2(uchar8, uchar8, uchar2);
+uchar2 __ovld __cnfn shuffle2(uchar16, uchar16, uchar2);
+
+short2 __ovld __cnfn shuffle2(short2, short2, ushort2);
+short2 __ovld __cnfn shuffle2(short4, short4, ushort2);
+short2 __ovld __cnfn shuffle2(short8, short8, ushort2);
+short2 __ovld __cnfn shuffle2(short16, short16, ushort2);
+
+ushort2 __ovld __cnfn shuffle2(ushort2, ushort2, ushort2);
+ushort2 __ovld __cnfn shuffle2(ushort4, ushort4, ushort2);
+ushort2 __ovld __cnfn shuffle2(ushort8, ushort8, ushort2);
+ushort2 __ovld __cnfn shuffle2(ushort16, ushort16, ushort2);
+
+int2 __ovld __cnfn shuffle2(int2, int2, uint2);
+int2 __ovld __cnfn shuffle2(int4, int4, uint2);
+int2 __ovld __cnfn shuffle2(int8, int8, uint2);
+int2 __ovld __cnfn shuffle2(int16, int16, uint2);
+
+uint2 __ovld __cnfn shuffle2(uint2, uint2, uint2);
+uint2 __ovld __cnfn shuffle2(uint4, uint4, uint2);
+uint2 __ovld __cnfn shuffle2(uint8, uint8, uint2);
+uint2 __ovld __cnfn shuffle2(uint16, uint16, uint2);
+
+long2 __ovld __cnfn shuffle2(long2, long2, ulong2);
+long2 __ovld __cnfn shuffle2(long4, long4, ulong2);
+long2 __ovld __cnfn shuffle2(long8, long8, ulong2);
+long2 __ovld __cnfn shuffle2(long16, long16, ulong2);
+
+ulong2 __ovld __cnfn shuffle2(ulong2, ulong2, ulong2);
+ulong2 __ovld __cnfn shuffle2(ulong4, ulong4, ulong2);
+ulong2 __ovld __cnfn shuffle2(ulong8, ulong8, ulong2);
+ulong2 __ovld __cnfn shuffle2(ulong16, ulong16, ulong2);
+
+float2 __ovld __cnfn shuffle2(float2, float2, uint2);
+float2 __ovld __cnfn shuffle2(float4, float4, uint2);
+float2 __ovld __cnfn shuffle2(float8, float8, uint2);
+float2 __ovld __cnfn shuffle2(float16, float16, uint2);
+
+char4 __ovld __cnfn shuffle2(char2, char2, uchar4);
+char4 __ovld __cnfn shuffle2(char4, char4, uchar4);
+char4 __ovld __cnfn shuffle2(char8, char8, uchar4);
+char4 __ovld __cnfn shuffle2(char16, char16, uchar4);
+
+uchar4 __ovld __cnfn shuffle2(uchar2, uchar2, uchar4);
+uchar4 __ovld __cnfn shuffle2(uchar4, uchar4, uchar4);
+uchar4 __ovld __cnfn shuffle2(uchar8, uchar8, uchar4);
+uchar4 __ovld __cnfn shuffle2(uchar16, uchar16, uchar4);
+
+short4 __ovld __cnfn shuffle2(short2, short2, ushort4);
+short4 __ovld __cnfn shuffle2(short4, short4, ushort4);
+short4 __ovld __cnfn shuffle2(short8, short8, ushort4);
+short4 __ovld __cnfn shuffle2(short16, short16, ushort4);
+
+ushort4 __ovld __cnfn shuffle2(ushort2, ushort2, ushort4);
+ushort4 __ovld __cnfn shuffle2(ushort4, ushort4, ushort4);
+ushort4 __ovld __cnfn shuffle2(ushort8, ushort8, ushort4);
+ushort4 __ovld __cnfn shuffle2(ushort16, ushort16, ushort4);
+
+int4 __ovld __cnfn shuffle2(int2, int2, uint4);
+int4 __ovld __cnfn shuffle2(int4, int4, uint4);
+int4 __ovld __cnfn shuffle2(int8, int8, uint4);
+int4 __ovld __cnfn shuffle2(int16, int16, uint4);
+
+uint4 __ovld __cnfn shuffle2(uint2, uint2, uint4);
+uint4 __ovld __cnfn shuffle2(uint4, uint4, uint4);
+uint4 __ovld __cnfn shuffle2(uint8, uint8, uint4);
+uint4 __ovld __cnfn shuffle2(uint16, uint16, uint4);
+
+long4 __ovld __cnfn shuffle2(long2, long2, ulong4);
+long4 __ovld __cnfn shuffle2(long4, long4, ulong4);
+long4 __ovld __cnfn shuffle2(long8, long8, ulong4);
+long4 __ovld __cnfn shuffle2(long16, long16, ulong4);
+
+ulong4 __ovld __cnfn shuffle2(ulong2, ulong2, ulong4);
+ulong4 __ovld __cnfn shuffle2(ulong4, ulong4, ulong4);
+ulong4 __ovld __cnfn shuffle2(ulong8, ulong8, ulong4);
+ulong4 __ovld __cnfn shuffle2(ulong16, ulong16, ulong4);
+
+float4 __ovld __cnfn shuffle2(float2, float2, uint4);
+float4 __ovld __cnfn shuffle2(float4, float4, uint4);
+float4 __ovld __cnfn shuffle2(float8, float8, uint4);
+float4 __ovld __cnfn shuffle2(float16, float16, uint4);
+
+char8 __ovld __cnfn shuffle2(char2, char2, uchar8);
+char8 __ovld __cnfn shuffle2(char4, char4, uchar8);
+char8 __ovld __cnfn shuffle2(char8, char8, uchar8);
+char8 __ovld __cnfn shuffle2(char16, char16, uchar8);
+
+uchar8 __ovld __cnfn shuffle2(uchar2, uchar2, uchar8);
+uchar8 __ovld __cnfn shuffle2(uchar4, uchar4, uchar8);
+uchar8 __ovld __cnfn shuffle2(uchar8, uchar8, uchar8);
+uchar8 __ovld __cnfn shuffle2(uchar16, uchar16, uchar8);
+
+short8 __ovld __cnfn shuffle2(short2, short2, ushort8);
+short8 __ovld __cnfn shuffle2(short4, short4, ushort8);
+short8 __ovld __cnfn shuffle2(short8, short8, ushort8);
+short8 __ovld __cnfn shuffle2(short16, short16, ushort8);
+
+ushort8 __ovld __cnfn shuffle2(ushort2, ushort2, ushort8);
+ushort8 __ovld __cnfn shuffle2(ushort4, ushort4, ushort8);
+ushort8 __ovld __cnfn shuffle2(ushort8, ushort8, ushort8);
+ushort8 __ovld __cnfn shuffle2(ushort16, ushort16, ushort8);
+
+int8 __ovld __cnfn shuffle2(int2, int2, uint8);
+int8 __ovld __cnfn shuffle2(int4, int4, uint8);
+int8 __ovld __cnfn shuffle2(int8, int8, uint8);
+int8 __ovld __cnfn shuffle2(int16, int16, uint8);
+
+uint8 __ovld __cnfn shuffle2(uint2, uint2, uint8);
+uint8 __ovld __cnfn shuffle2(uint4, uint4, uint8);
+uint8 __ovld __cnfn shuffle2(uint8, uint8, uint8);
+uint8 __ovld __cnfn shuffle2(uint16, uint16, uint8);
+
+long8 __ovld __cnfn shuffle2(long2, long2, ulong8);
+long8 __ovld __cnfn shuffle2(long4, long4, ulong8);
+long8 __ovld __cnfn shuffle2(long8, long8, ulong8);
+long8 __ovld __cnfn shuffle2(long16, long16, ulong8);
+
+ulong8 __ovld __cnfn shuffle2(ulong2, ulong2, ulong8);
+ulong8 __ovld __cnfn shuffle2(ulong4, ulong4, ulong8);
+ulong8 __ovld __cnfn shuffle2(ulong8, ulong8, ulong8);
+ulong8 __ovld __cnfn shuffle2(ulong16, ulong16, ulong8);
+
+float8 __ovld __cnfn shuffle2(float2, float2, uint8);
+float8 __ovld __cnfn shuffle2(float4, float4, uint8);
+float8 __ovld __cnfn shuffle2(float8, float8, uint8);
+float8 __ovld __cnfn shuffle2(float16, float16, uint8);
+
+char16 __ovld __cnfn shuffle2(char2, char2, uchar16);
+char16 __ovld __cnfn shuffle2(char4, char4, uchar16);
+char16 __ovld __cnfn shuffle2(char8, char8, uchar16);
+char16 __ovld __cnfn shuffle2(char16, char16, uchar16);
+
+uchar16 __ovld __cnfn shuffle2(uchar2, uchar2, uchar16);
+uchar16 __ovld __cnfn shuffle2(uchar4, uchar4, uchar16);
+uchar16 __ovld __cnfn shuffle2(uchar8, uchar8, uchar16);
+uchar16 __ovld __cnfn shuffle2(uchar16, uchar16, uchar16);
+
+short16 __ovld __cnfn shuffle2(short2, short2, ushort16);
+short16 __ovld __cnfn shuffle2(short4, short4, ushort16);
+short16 __ovld __cnfn shuffle2(short8, short8, ushort16);
+short16 __ovld __cnfn shuffle2(short16, short16, ushort16);
+
+ushort16 __ovld __cnfn shuffle2(ushort2, ushort2, ushort16);
+ushort16 __ovld __cnfn shuffle2(ushort4, ushort4, ushort16);
+ushort16 __ovld __cnfn shuffle2(ushort8, ushort8, ushort16);
+ushort16 __ovld __cnfn shuffle2(ushort16, ushort16, ushort16);
+
+int16 __ovld __cnfn shuffle2(int2, int2, uint16);
+int16 __ovld __cnfn shuffle2(int4, int4, uint16);
+int16 __ovld __cnfn shuffle2(int8, int8, uint16);
+int16 __ovld __cnfn shuffle2(int16, int16, uint16);
+
+uint16 __ovld __cnfn shuffle2(uint2, uint2, uint16);
+uint16 __ovld __cnfn shuffle2(uint4, uint4, uint16);
+uint16 __ovld __cnfn shuffle2(uint8, uint8, uint16);
+uint16 __ovld __cnfn shuffle2(uint16, uint16, uint16);
+
+long16 __ovld __cnfn shuffle2(long2, long2, ulong16);
+long16 __ovld __cnfn shuffle2(long4, long4, ulong16);
+long16 __ovld __cnfn shuffle2(long8, long8, ulong16);
+long16 __ovld __cnfn shuffle2(long16, long16, ulong16);
+
+ulong16 __ovld __cnfn shuffle2(ulong2, ulong2, ulong16);
+ulong16 __ovld __cnfn shuffle2(ulong4, ulong4, ulong16);
+ulong16 __ovld __cnfn shuffle2(ulong8, ulong8, ulong16);
+ulong16 __ovld __cnfn shuffle2(ulong16, ulong16, ulong16);
+
+float16 __ovld __cnfn shuffle2(float2, float2, uint16);
+float16 __ovld __cnfn shuffle2(float4, float4, uint16);
+float16 __ovld __cnfn shuffle2(float8, float8, uint16);
+float16 __ovld __cnfn shuffle2(float16, float16, uint16);
+
+#ifdef cl_khr_fp64
+double2 __ovld __cnfn shuffle2(double2, double2, ulong2);
+double2 __ovld __cnfn shuffle2(double4, double4, ulong2);
+double2 __ovld __cnfn shuffle2(double8, double8, ulong2);
+double2 __ovld __cnfn shuffle2(double16, double16, ulong2);
+
+double4 __ovld __cnfn shuffle2(double2, double2, ulong4);
+double4 __ovld __cnfn shuffle2(double4, double4, ulong4);
+double4 __ovld __cnfn shuffle2(double8, double8, ulong4);
+double4 __ovld __cnfn shuffle2(double16, double16, ulong4);
+
+double8 __ovld __cnfn shuffle2(double2, double2, ulong8);
+double8 __ovld __cnfn shuffle2(double4, double4, ulong8);
+double8 __ovld __cnfn shuffle2(double8, double8, ulong8);
+double8 __ovld __cnfn shuffle2(double16, double16, ulong8);
+
+double16 __ovld __cnfn shuffle2(double2, double2, ulong16);
+double16 __ovld __cnfn shuffle2(double4, double4, ulong16);
+double16 __ovld __cnfn shuffle2(double8, double8, ulong16);
+double16 __ovld __cnfn shuffle2(double16, double16, ulong16);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+half2 __ovld __cnfn shuffle2(half2, half2, ushort2);
+half2 __ovld __cnfn shuffle2(half4, half4, ushort2);
+half2 __ovld __cnfn shuffle2(half8, half8, ushort2);
+half2 __ovld __cnfn shuffle2(half16, half16, ushort2);
+
+half4 __ovld __cnfn shuffle2(half2, half2, ushort4);
+half4 __ovld __cnfn shuffle2(half4, half4, ushort4);
+half4 __ovld __cnfn shuffle2(half8, half8, ushort4);
+half4 __ovld __cnfn shuffle2(half16, half16, ushort4);
+
+half8 __ovld __cnfn shuffle2(half2, half2, ushort8);
+half8 __ovld __cnfn shuffle2(half4, half4, ushort8);
+half8 __ovld __cnfn shuffle2(half8, half8, ushort8);
+half8 __ovld __cnfn shuffle2(half16, half16, ushort8);
+
+half16 __ovld __cnfn shuffle2(half2, half2, ushort16);
+half16 __ovld __cnfn shuffle2(half4, half4, ushort16);
+half16 __ovld __cnfn shuffle2(half8, half8, ushort16);
+half16 __ovld __cnfn shuffle2(half16, half16, ushort16);
+#endif //cl_khr_fp16
+
+// OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions
+#ifdef __opencl_c_images
+
+#ifdef cl_khr_gl_msaa_sharing
+#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable
+#endif //cl_khr_gl_msaa_sharing
+
+/**
+ * Use the coordinate (coord.xy) to do an element lookup in
+ * the 2D image object specified by image.
+ *
+ * Use the coordinate (coord.x, coord.y, coord.z) to do
+ * an element lookup in the 3D image object specified
+ * by image. coord.w is ignored.
+ *
+ * Use the coordinate (coord.z) to index into the
+ * 2D image array object specified by image_array
+ * and (coord.x, coord.y) to do an element lookup in
+ * the 2D image object specified by image.
+ *
+ * Use the coordinate (x) to do an element lookup in
+ * the 1D image object specified by image.
+ *
+ * Use the coordinate (coord.y) to index into the
+ * 1D image array object specified by image_array
+ * and (coord.x) to do an element lookup in
+ * the 1D image object specified by image.
+ *
+ * Use the coordinate (cood.xy) and sample to do an
+ * element lookup in the 2D multi-sample image specified
+ * by image.
+ *
+ * Use coord.xy and sample to do an element
+ * lookup in the 2D multi-sample image layer
+ * identified by index coord.z in the 2D multi-sample
+ * image array specified by image.
+ *
+ * For mipmap images, use the mip-level specified by
+ * the Level-of-Detail (lod) or use gradients for LOD
+ * computation.
+ *
+ * read_imagef returns floating-point values in the
+ * range [0.0 ... 1.0] for image objects created with
+ * image_channel_data_type set to one of the predefined
+ * packed formats or CL_UNORM_INT8, or
+ * CL_UNORM_INT16.
+ *
+ * read_imagef returns floating-point values in the
+ * range [-1.0 ... 1.0] for image objects created with
+ * image_channel_data_type set to CL_SNORM_INT8,
+ * or CL_SNORM_INT16.
+ *
+ * read_imagef returns floating-point values for image
+ * objects created with image_channel_data_type set to
+ * CL_HALF_FLOAT or CL_FLOAT.
+ *
+ * read_imagei and read_imageui return
+ * unnormalized signed integer and unsigned integer
+ * values respectively. Each channel will be stored in a
+ * 32-bit integer.
+ *
+ * read_imagei can only be used with image objects
+ * created with image_channel_data_type set to one of
+ * the following values:
+ * CL_SIGNED_INT8,
+ * CL_SIGNED_INT16 and
+ * CL_SIGNED_INT32.
+ * If the image_channel_data_type is not one of the
+ * above values, the values returned by read_imagei
+ * are undefined.
+ *
+ * read_imageui can only be used with image objects
+ * created with image_channel_data_type set to one of
+ * the following values:
+ * CL_UNSIGNED_INT8,
+ * CL_UNSIGNED_INT16 and
+ * CL_UNSIGNED_INT32.
+ * If the image_channel_data_type is not one of the
+ * above values, the values returned by read_imageui
+ * are undefined.
+ *
+ * The read_image{i|ui} calls support a nearest filter
+ * only. The filter_mode specified in sampler
+ * must be set to CLK_FILTER_NEAREST; otherwise
+ * the values returned are undefined.
+
+ * The read_image{f|i|ui} calls that take
+ * integer coordinates must use a sampler with
+ * normalized coordinates set to
+ * CLK_NORMALIZED_COORDS_FALSE and
+ * addressing mode set to
+ * CLK_ADDRESS_CLAMP_TO_EDGE,
+ * CLK_ADDRESS_CLAMP or CLK_ADDRESS_NONE;
+ * otherwise the values returned are undefined.
+ *
+ * Values returned by read_imagef for image objects
+ * with image_channel_data_type values not specified
+ * in the description above are undefined.
+ */
+
+float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, int2);
+float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2);
+
+int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, int2);
+int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2);
+uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, int2);
+uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2);
+
+float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, int4);
+float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4);
+
+int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, int4);
+int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4);
+uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, int4);
+uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4);
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, int4);
+float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4);
+
+int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, int4);
+int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4);
+uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, int4);
+uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+
+float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, int);
+float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float);
+
+int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, int);
+int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float);
+uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, int);
+uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float);
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, int2);
+float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2);
+
+int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, int2);
+int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2);
+uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, int2);
+uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2);
+float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, int2);
+
+float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4);
+float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, int4);
+#endif //cl_khr_depth_images
+
+#if defined(cl_khr_gl_msaa_sharing)
+float4 __ovld __purefn read_imagef(read_only image2d_msaa_t, int2, int);
+int4 __ovld __purefn read_imagei(read_only image2d_msaa_t, int2, int);
+uint4 __ovld __purefn read_imageui(read_only image2d_msaa_t, int2, int);
+
+float __ovld __purefn read_imagef(read_only image2d_msaa_depth_t, int2, int);
+
+float4 __ovld __purefn read_imagef(read_only image2d_array_msaa_t, int4, int);
+int4 __ovld __purefn read_imagei(read_only image2d_array_msaa_t, int4, int);
+uint4 __ovld __purefn read_imageui(read_only image2d_array_msaa_t, int4, int);
+
+float __ovld __purefn read_imagef(read_only image2d_array_msaa_depth_t, int4, int);
+#endif //cl_khr_gl_msaa_sharing
+
+// OpenCL Extension v2.0 s9.18 - Mipmaps
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#ifdef cl_khr_mipmap_image
+
+float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float, float);
+int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float, float);
+uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float);
+
+float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2, float);
+int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2, float);
+uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2, float);
+
+float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2, float);
+int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2, float);
+uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2, float);
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2, float);
+#endif // cl_khr_depth_images
+
+float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4, float);
+int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4, float);
+uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4, float);
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4, float);
+#endif // cl_khr_depth_images
+
+float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4, float);
+int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4, float);
+uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4, float);
+
+float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float, float, float);
+int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float, float, float);
+uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float, float);
+
+float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2, float, float);
+int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2, float, float);
+uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2, float, float);
+
+float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2, float2, float2);
+int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2, float2, float2);
+uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2, float2, float2);
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2, float2, float2);
+#endif // cl_khr_depth_images
+
+float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4, float2, float2);
+int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4, float2, float2);
+uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4, float2, float2);
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4, float2, float2);
+#endif // cl_khr_depth_images
+
+float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4, float4, float4);
+int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4, float4, float4);
+uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4, float4, float4);
+
+#endif //cl_khr_mipmap_image
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+
+/**
+* Sampler-less Image Access
+*/
+
+float4 __ovld __purefn read_imagef(read_only image1d_t, int);
+int4 __ovld __purefn read_imagei(read_only image1d_t, int);
+uint4 __ovld __purefn read_imageui(read_only image1d_t, int);
+
+float4 __ovld __purefn read_imagef(read_only image1d_buffer_t, int);
+int4 __ovld __purefn read_imagei(read_only image1d_buffer_t, int);
+uint4 __ovld __purefn read_imageui(read_only image1d_buffer_t, int);
+
+float4 __ovld __purefn read_imagef(read_only image1d_array_t, int2);
+int4 __ovld __purefn read_imagei(read_only image1d_array_t, int2);
+uint4 __ovld __purefn read_imageui(read_only image1d_array_t, int2);
+
+float4 __ovld __purefn read_imagef(read_only image2d_t, int2);
+int4 __ovld __purefn read_imagei(read_only image2d_t, int2);
+uint4 __ovld __purefn read_imageui(read_only image2d_t, int2);
+
+float4 __ovld __purefn read_imagef(read_only image2d_array_t, int4);
+int4 __ovld __purefn read_imagei(read_only image2d_array_t, int4);
+uint4 __ovld __purefn read_imageui(read_only image2d_array_t, int4);
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_only image2d_depth_t, int2);
+float __ovld __purefn read_imagef(read_only image2d_array_depth_t, int4);
+#endif //cl_khr_depth_images
+
+float4 __ovld __purefn read_imagef(read_only image3d_t, int4);
+int4 __ovld __purefn read_imagei(read_only image3d_t, int4);
+uint4 __ovld __purefn read_imageui(read_only image3d_t, int4);
+
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+
+// Image read functions returning half4 type
+#ifdef cl_khr_fp16
+half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, int);
+half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, float);
+half4 __ovld __purefn read_imageh(read_only image2d_t, sampler_t, int2);
+half4 __ovld __purefn read_imageh(read_only image2d_t, sampler_t, float2);
+half4 __ovld __purefn read_imageh(read_only image3d_t, sampler_t, int4);
+half4 __ovld __purefn read_imageh(read_only image3d_t, sampler_t, float4);
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+half4 __ovld __purefn read_imageh(read_only image1d_array_t, sampler_t, int2);
+half4 __ovld __purefn read_imageh(read_only image1d_array_t, sampler_t, float2);
+half4 __ovld __purefn read_imageh(read_only image2d_array_t, sampler_t, int4);
+half4 __ovld __purefn read_imageh(read_only image2d_array_t, sampler_t, float4);
+/**
+ * Sampler-less Image Access
+ */
+half4 __ovld __purefn read_imageh(read_only image1d_t, int);
+half4 __ovld __purefn read_imageh(read_only image2d_t, int2);
+half4 __ovld __purefn read_imageh(read_only image3d_t, int4);
+half4 __ovld __purefn read_imageh(read_only image1d_array_t, int2);
+half4 __ovld __purefn read_imageh(read_only image2d_array_t, int4);
+half4 __ovld __purefn read_imageh(read_only image1d_buffer_t, int);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+#endif //cl_khr_fp16
+
+// Image read functions for read_write images
+#if defined(__opencl_c_read_write_images)
+float4 __ovld __purefn read_imagef(read_write image1d_t, int);
+int4 __ovld __purefn read_imagei(read_write image1d_t, int);
+uint4 __ovld __purefn read_imageui(read_write image1d_t, int);
+
+float4 __ovld __purefn read_imagef(read_write image1d_buffer_t, int);
+int4 __ovld __purefn read_imagei(read_write image1d_buffer_t, int);
+uint4 __ovld __purefn read_imageui(read_write image1d_buffer_t, int);
+
+float4 __ovld __purefn read_imagef(read_write image1d_array_t, int2);
+int4 __ovld __purefn read_imagei(read_write image1d_array_t, int2);
+uint4 __ovld __purefn read_imageui(read_write image1d_array_t, int2);
+
+float4 __ovld __purefn read_imagef(read_write image2d_t, int2);
+int4 __ovld __purefn read_imagei(read_write image2d_t, int2);
+uint4 __ovld __purefn read_imageui(read_write image2d_t, int2);
+
+float4 __ovld __purefn read_imagef(read_write image2d_array_t, int4);
+int4 __ovld __purefn read_imagei(read_write image2d_array_t, int4);
+uint4 __ovld __purefn read_imageui(read_write image2d_array_t, int4);
+
+#ifdef cl_khr_3d_image_writes
+float4 __ovld __purefn read_imagef(read_write image3d_t, int4);
+int4 __ovld __purefn read_imagei(read_write image3d_t, int4);
+uint4 __ovld __purefn read_imageui(read_write image3d_t, int4);
+#endif // cl_khr_3d_image_writes
+
+#ifdef cl_khr_depth_images
+float __ovld __purefn read_imagef(read_write image2d_depth_t, int2);
+float __ovld __purefn read_imagef(read_write image2d_array_depth_t, int4);
+#endif //cl_khr_depth_images
+
+#if cl_khr_gl_msaa_sharing
+float4 __ovld __purefn read_imagef(read_write image2d_msaa_t, int2, int);
+int4 __ovld __purefn read_imagei(read_write image2d_msaa_t, int2, int);
+uint4 __ovld __purefn read_imageui(read_write image2d_msaa_t, int2, int);
+
+float4 __ovld __purefn read_imagef(read_write image2d_array_msaa_t, int4, int);
+int4 __ovld __purefn read_imagei(read_write image2d_array_msaa_t, int4, int);
+uint4 __ovld __purefn read_imageui(read_write image2d_array_msaa_t, int4, int);
+
+float __ovld __purefn read_imagef(read_write image2d_msaa_depth_t, int2, int);
+float __ovld __purefn read_imagef(read_write image2d_array_msaa_depth_t, int4, int);
+#endif //cl_khr_gl_msaa_sharing
+
+#ifdef cl_khr_mipmap_image
+float4 __ovld __purefn read_imagef(read_write image1d_t, sampler_t, float, float);
+int4 __ovld __purefn read_imagei(read_write image1d_t, sampler_t, float, float);
+uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float);
+
+float4 __ovld __purefn read_imagef(read_write image1d_array_t, sampler_t, float2, float);
+int4 __ovld __purefn read_imagei(read_write image1d_array_t, sampler_t, float2, float);
+uint4 __ovld __purefn read_imageui(read_write image1d_array_t, sampler_t, float2, float);
+
+float4 __ovld __purefn read_imagef(read_write image2d_t, sampler_t, float2, float);
+int4 __ovld __purefn read_imagei(read_write image2d_t, sampler_t, float2, float);
+uint4 __ovld __purefn read_imageui(read_write image2d_t, sampler_t, float2, float);
+
+float __ovld __purefn read_imagef(read_write image2d_depth_t, sampler_t, float2, float);
+
+float4 __ovld __purefn read_imagef(read_write image2d_array_t, sampler_t, float4, float);
+int4 __ovld __purefn read_imagei(read_write image2d_array_t, sampler_t, float4, float);
+uint4 __ovld __purefn read_imageui(read_write image2d_array_t, sampler_t, float4, float);
+
+float __ovld __purefn read_imagef(read_write image2d_array_depth_t, sampler_t, float4, float);
+
+#ifdef cl_khr_3d_image_writes
+float4 __ovld __purefn read_imagef(read_write image3d_t, sampler_t, float4, float);
+int4 __ovld __purefn read_imagei(read_write image3d_t, sampler_t, float4, float);
+uint4 __ovld __purefn read_imageui(read_write image3d_t, sampler_t, float4, float);
+#endif // cl_khr_3d_image_writes
+
+float4 __ovld __purefn read_imagef(read_write image1d_t, sampler_t, float, float, float);
+int4 __ovld __purefn read_imagei(read_write image1d_t, sampler_t, float, float, float);
+uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float, float);
+
+float4 __ovld __purefn read_imagef(read_write image1d_array_t, sampler_t, float2, float, float);
+int4 __ovld __purefn read_imagei(read_write image1d_array_t, sampler_t, float2, float, float);
+uint4 __ovld __purefn read_imageui(read_write image1d_array_t, sampler_t, float2, float, float);
+
+float4 __ovld __purefn read_imagef(read_write image2d_t, sampler_t, float2, float2, float2);
+int4 __ovld __purefn read_imagei(read_write image2d_t, sampler_t, float2, float2, float2);
+uint4 __ovld __purefn read_imageui(read_write image2d_t, sampler_t, float2, float2, float2);
+
+float __ovld __purefn read_imagef(read_write image2d_depth_t, sampler_t, float2, float2, float2);
+
+float4 __ovld __purefn read_imagef(read_write image2d_array_t, sampler_t, float4, float2, float2);
+int4 __ovld __purefn read_imagei(read_write image2d_array_t, sampler_t, float4, float2, float2);
+uint4 __ovld __purefn read_imageui(read_write image2d_array_t, sampler_t, float4, float2, float2);
+
+float __ovld __purefn read_imagef(read_write image2d_array_depth_t, sampler_t, float4, float2, float2);
+
+#ifdef cl_khr_3d_image_writes
+float4 __ovld __purefn read_imagef(read_write image3d_t, sampler_t, float4, float4, float4);
+int4 __ovld __purefn read_imagei(read_write image3d_t, sampler_t, float4, float4, float4);
+uint4 __ovld __purefn read_imageui(read_write image3d_t, sampler_t, float4, float4, float4);
+#endif // cl_khr_3d_image_writes
+
+#endif //cl_khr_mipmap_image
+
+// Image read functions returning half4 type
+#ifdef cl_khr_fp16
+half4 __ovld __purefn read_imageh(read_write image1d_t, int);
+half4 __ovld __purefn read_imageh(read_write image2d_t, int2);
+#ifdef cl_khr_3d_image_writes
+half4 __ovld __purefn read_imageh(read_write image3d_t, int4);
+#endif // cl_khr_3d_image_writes
+half4 __ovld __purefn read_imageh(read_write image1d_array_t, int2);
+half4 __ovld __purefn read_imageh(read_write image2d_array_t, int4);
+half4 __ovld __purefn read_imageh(read_write image1d_buffer_t, int);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+ * Write color value to location specified by coordinate
+ * (coord.x, coord.y) in the 2D image object specified by image.
+ * (coord.x, coord.y) are considered to be unnormalized coordinates
+ * and must be in the range 0 ... image width - 1, and 0
+ * ... image height - 1.
+
+ * Write color value to location specified by coordinate
+ * (coord.x, coord.y) in the 2D image object specified by index
+ * (coord.z) of the 2D image array object image_array.
+ * (coord.x, coord.y) are considered to be unnormalized
+ * coordinates and must be in the range 0 ... image width
+ * - 1.
+ *
+ * Write color value to location specified by coordinate
+ * (coord) in the 1D image (buffer) object specified by image.
+ * coord is considered to be unnormalized coordinates
+ * and must be in the range 0 ... image width - 1.
+ *
+ * Write color value to location specified by coordinate
+ * (coord.x) in the 1D image object specified by index
+ * (coord.y) of the 1D image array object image_array.
+ * x is considered to be unnormalized coordinates
+ * and must be in the range 0 ... image width - 1.
+ *
+ * Write color value to location specified by coordinate
+ * (coord.x, coord.y, coord.z) in the 3D image object specified by image.
+ * coord.x & coord.y are considered to be unnormalized coordinates
+ * and must be in the range 0 ... image width - 1, and 0
+ * ... image height - 1.
+ *
+ * For mipmap images, use mip-level specified by lod.
+ *
+ * Appropriate data format conversion to the specified
+ * image format is done before writing the color value.
+ *
+ * write_imagef can only be used with image objects
+ * created with image_channel_data_type set to one of
+ * the pre-defined packed formats or set to
+ * CL_SNORM_INT8, CL_UNORM_INT8,
+ * CL_SNORM_INT16, CL_UNORM_INT16,
+ * CL_HALF_FLOAT or CL_FLOAT. Appropriate data
+ * format conversion will be done to convert channel
+ * data from a floating-point value to actual data format
+ * in which the channels are stored.
+ *
+ * write_imagei can only be used with image objects
+ * created with image_channel_data_type set to one of
+ * the following values:
+ * CL_SIGNED_INT8,
+ * CL_SIGNED_INT16 and
+ * CL_SIGNED_INT32.
+ *
+ * write_imageui can only be used with image objects
+ * created with image_channel_data_type set to one of
+ * the following values:
+ * CL_UNSIGNED_INT8,
+ * CL_UNSIGNED_INT16 and
+ * CL_UNSIGNED_INT32.
+ *
+ * The behavior of write_imagef, write_imagei and
+ * write_imageui for image objects created with
+ * image_channel_data_type values not specified in
+ * the description above or with (x, y) coordinate
+ * values that are not in the range (0 ... image width -1,
+ * 0 ... image height - 1), respectively, is undefined.
+ */
+void __ovld write_imagef(write_only image2d_t, int2, float4);
+void __ovld write_imagei(write_only image2d_t, int2, int4);
+void __ovld write_imageui(write_only image2d_t, int2, uint4);
+
+void __ovld write_imagef(write_only image2d_array_t, int4, float4);
+void __ovld write_imagei(write_only image2d_array_t, int4, int4);
+void __ovld write_imageui(write_only image2d_array_t, int4, uint4);
+
+void __ovld write_imagef(write_only image1d_t, int, float4);
+void __ovld write_imagei(write_only image1d_t, int, int4);
+void __ovld write_imageui(write_only image1d_t, int, uint4);
+
+void __ovld write_imagef(write_only image1d_buffer_t, int, float4);
+void __ovld write_imagei(write_only image1d_buffer_t, int, int4);
+void __ovld write_imageui(write_only image1d_buffer_t, int, uint4);
+
+void __ovld write_imagef(write_only image1d_array_t, int2, float4);
+void __ovld write_imagei(write_only image1d_array_t, int2, int4);
+void __ovld write_imageui(write_only image1d_array_t, int2, uint4);
+
+#ifdef cl_khr_3d_image_writes
+void __ovld write_imagef(write_only image3d_t, int4, float4);
+void __ovld write_imagei(write_only image3d_t, int4, int4);
+void __ovld write_imageui(write_only image3d_t, int4, uint4);
+#endif
+
+#ifdef cl_khr_depth_images
+void __ovld write_imagef(write_only image2d_depth_t, int2, float);
+void __ovld write_imagef(write_only image2d_array_depth_t, int4, float);
+#endif //cl_khr_depth_images
+
+// OpenCL Extension v2.0 s9.18 - Mipmaps
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(cl_khr_mipmap_image_writes)
+void __ovld write_imagef(write_only image1d_t, int, int, float4);
+void __ovld write_imagei(write_only image1d_t, int, int, int4);
+void __ovld write_imageui(write_only image1d_t, int, int, uint4);
+
+void __ovld write_imagef(write_only image1d_array_t, int2, int, float4);
+void __ovld write_imagei(write_only image1d_array_t, int2, int, int4);
+void __ovld write_imageui(write_only image1d_array_t, int2, int, uint4);
+
+void __ovld write_imagef(write_only image2d_t, int2, int, float4);
+void __ovld write_imagei(write_only image2d_t, int2, int, int4);
+void __ovld write_imageui(write_only image2d_t, int2, int, uint4);
+
+void __ovld write_imagef(write_only image2d_array_t, int4, int, float4);
+void __ovld write_imagei(write_only image2d_array_t, int4, int, int4);
+void __ovld write_imageui(write_only image2d_array_t, int4, int, uint4);
+
+void __ovld write_imagef(write_only image2d_depth_t, int2, int, float);
+void __ovld write_imagef(write_only image2d_array_depth_t, int4, int, float);
+
+#ifdef cl_khr_3d_image_writes
+void __ovld write_imagef(write_only image3d_t, int4, int, float4);
+void __ovld write_imagei(write_only image3d_t, int4, int, int4);
+void __ovld write_imageui(write_only image3d_t, int4, int, uint4);
+#endif //cl_khr_3d_image_writes
+
+#endif //defined(cl_khr_mipmap_image_writes)
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// Image write functions for half4 type
+#ifdef cl_khr_fp16
+void __ovld write_imageh(write_only image1d_t, int, half4);
+void __ovld write_imageh(write_only image2d_t, int2, half4);
+#ifdef cl_khr_3d_image_writes
+void __ovld write_imageh(write_only image3d_t, int4, half4);
+#endif
+void __ovld write_imageh(write_only image1d_array_t, int2, half4);
+void __ovld write_imageh(write_only image2d_array_t, int4, half4);
+void __ovld write_imageh(write_only image1d_buffer_t, int, half4);
+#endif //cl_khr_fp16
+
+// Image write functions for read_write images
+#if defined(__opencl_c_read_write_images)
+void __ovld write_imagef(read_write image2d_t, int2, float4);
+void __ovld write_imagei(read_write image2d_t, int2, int4);
+void __ovld write_imageui(read_write image2d_t, int2, uint4);
+
+void __ovld write_imagef(read_write image2d_array_t, int4, float4);
+void __ovld write_imagei(read_write image2d_array_t, int4, int4);
+void __ovld write_imageui(read_write image2d_array_t, int4, uint4);
+
+void __ovld write_imagef(read_write image1d_t, int, float4);
+void __ovld write_imagei(read_write image1d_t, int, int4);
+void __ovld write_imageui(read_write image1d_t, int, uint4);
+
+void __ovld write_imagef(read_write image1d_buffer_t, int, float4);
+void __ovld write_imagei(read_write image1d_buffer_t, int, int4);
+void __ovld write_imageui(read_write image1d_buffer_t, int, uint4);
+
+void __ovld write_imagef(read_write image1d_array_t, int2, float4);
+void __ovld write_imagei(read_write image1d_array_t, int2, int4);
+void __ovld write_imageui(read_write image1d_array_t, int2, uint4);
+
+#ifdef cl_khr_3d_image_writes
+void __ovld write_imagef(read_write image3d_t, int4, float4);
+void __ovld write_imagei(read_write image3d_t, int4, int4);
+void __ovld write_imageui(read_write image3d_t, int4, uint4);
+#endif
+
+#ifdef cl_khr_depth_images
+void __ovld write_imagef(read_write image2d_depth_t, int2, float);
+void __ovld write_imagef(read_write image2d_array_depth_t, int4, float);
+#endif //cl_khr_depth_images
+
+#if defined(cl_khr_mipmap_image_writes)
+void __ovld write_imagef(read_write image1d_t, int, int, float4);
+void __ovld write_imagei(read_write image1d_t, int, int, int4);
+void __ovld write_imageui(read_write image1d_t, int, int, uint4);
+
+void __ovld write_imagef(read_write image1d_array_t, int2, int, float4);
+void __ovld write_imagei(read_write image1d_array_t, int2, int, int4);
+void __ovld write_imageui(read_write image1d_array_t, int2, int, uint4);
+
+void __ovld write_imagef(read_write image2d_t, int2, int, float4);
+void __ovld write_imagei(read_write image2d_t, int2, int, int4);
+void __ovld write_imageui(read_write image2d_t, int2, int, uint4);
+
+void __ovld write_imagef(read_write image2d_array_t, int4, int, float4);
+void __ovld write_imagei(read_write image2d_array_t, int4, int, int4);
+void __ovld write_imageui(read_write image2d_array_t, int4, int, uint4);
+
+void __ovld write_imagef(read_write image2d_depth_t, int2, int, float);
+void __ovld write_imagef(read_write image2d_array_depth_t, int4, int, float);
+
+#ifdef cl_khr_3d_image_writes
+void __ovld write_imagef(read_write image3d_t, int4, int, float4);
+void __ovld write_imagei(read_write image3d_t, int4, int, int4);
+void __ovld write_imageui(read_write image3d_t, int4, int, uint4);
+#endif //cl_khr_3d_image_writes
+
+#endif //cl_khr_mipmap_image_writes
+
+// Image write functions for half4 type
+#ifdef cl_khr_fp16
+void __ovld write_imageh(read_write image1d_t, int, half4);
+void __ovld write_imageh(read_write image2d_t, int2, half4);
+#ifdef cl_khr_3d_image_writes
+void __ovld write_imageh(read_write image3d_t, int4, half4);
+#endif
+void __ovld write_imageh(read_write image1d_array_t, int2, half4);
+void __ovld write_imageh(read_write image2d_array_t, int4, half4);
+void __ovld write_imageh(read_write image1d_buffer_t, int, half4);
+#endif //cl_khr_fp16
+#endif //defined(__opencl_c_read_write_images)
+
+// Note: In OpenCL v1.0/1.1/1.2, image argument of image query builtin functions does not have
+// access qualifier, which by default assume read_only access qualifier. Image query builtin
+// functions with write_only image argument should also be declared.
+
+/**
+ * Return the image width in pixels.
+ *
+  */
+int __ovld __cnfn get_image_width(read_only image1d_t);
+int __ovld __cnfn get_image_width(read_only image1d_buffer_t);
+int __ovld __cnfn get_image_width(read_only image2d_t);
+int __ovld __cnfn get_image_width(read_only image3d_t);
+int __ovld __cnfn get_image_width(read_only image1d_array_t);
+int __ovld __cnfn get_image_width(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_width(read_only image2d_depth_t);
+int __ovld __cnfn get_image_width(read_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_width(read_only image2d_msaa_t);
+int __ovld __cnfn get_image_width(read_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_width(read_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+int __ovld __cnfn get_image_width(write_only image1d_t);
+int __ovld __cnfn get_image_width(write_only image1d_buffer_t);
+int __ovld __cnfn get_image_width(write_only image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_width(write_only image3d_t);
+#endif
+int __ovld __cnfn get_image_width(write_only image1d_array_t);
+int __ovld __cnfn get_image_width(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_width(write_only image2d_depth_t);
+int __ovld __cnfn get_image_width(write_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_width(write_only image2d_msaa_t);
+int __ovld __cnfn get_image_width(write_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_width(write_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_width(write_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+#if defined(__opencl_c_read_write_images)
+int __ovld __cnfn get_image_width(read_write image1d_t);
+int __ovld __cnfn get_image_width(read_write image1d_buffer_t);
+int __ovld __cnfn get_image_width(read_write image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_width(read_write image3d_t);
+#endif // cl_khr_3d_image_writes
+int __ovld __cnfn get_image_width(read_write image1d_array_t);
+int __ovld __cnfn get_image_width(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_width(read_write image2d_depth_t);
+int __ovld __cnfn get_image_width(read_write image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_width(read_write image2d_msaa_t);
+int __ovld __cnfn get_image_width(read_write image2d_msaa_depth_t);
+int __ovld __cnfn get_image_width(read_write image2d_array_msaa_t);
+int __ovld __cnfn get_image_width(read_write image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+ * Return the image height in pixels.
+ */
+int __ovld __cnfn get_image_height(read_only image2d_t);
+int __ovld __cnfn get_image_height(read_only image3d_t);
+int __ovld __cnfn get_image_height(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_height(read_only image2d_depth_t);
+int __ovld __cnfn get_image_height(read_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_height(read_only image2d_msaa_t);
+int __ovld __cnfn get_image_height(read_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_height(read_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+int __ovld __cnfn get_image_height(write_only image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_height(write_only image3d_t);
+#endif
+int __ovld __cnfn get_image_height(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_height(write_only image2d_depth_t);
+int __ovld __cnfn get_image_height(write_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_height(write_only image2d_msaa_t);
+int __ovld __cnfn get_image_height(write_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_height(write_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_height(write_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+#if defined(__opencl_c_read_write_images)
+int __ovld __cnfn get_image_height(read_write image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_height(read_write image3d_t);
+#endif // cl_khr_3d_image_writes
+int __ovld __cnfn get_image_height(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_height(read_write image2d_depth_t);
+int __ovld __cnfn get_image_height(read_write image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_height(read_write image2d_msaa_t);
+int __ovld __cnfn get_image_height(read_write image2d_msaa_depth_t);
+int __ovld __cnfn get_image_height(read_write image2d_array_msaa_t);
+int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+ * Return the image depth in pixels.
+ */
+int __ovld __cnfn get_image_depth(read_only image3d_t);
+
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_depth(write_only image3d_t);
+
+#if defined(__opencl_c_read_write_images)
+int __ovld __cnfn get_image_depth(read_write image3d_t);
+#endif //defined(__opencl_c_read_write_images)
+#endif // cl_khr_3d_image_writes
+
+// OpenCL Extension v2.0 s9.18 - Mipmaps
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#ifdef cl_khr_mipmap_image
+/**
+ * Return the image miplevels.
+ */
+
+int __ovld get_image_num_mip_levels(read_only image1d_t);
+int __ovld get_image_num_mip_levels(read_only image2d_t);
+int __ovld get_image_num_mip_levels(read_only image3d_t);
+
+int __ovld get_image_num_mip_levels(write_only image1d_t);
+int __ovld get_image_num_mip_levels(write_only image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld get_image_num_mip_levels(write_only image3d_t);
+#endif
+
+#if defined(__opencl_c_read_write_images)
+int __ovld get_image_num_mip_levels(read_write image1d_t);
+int __ovld get_image_num_mip_levels(read_write image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld get_image_num_mip_levels(read_write image3d_t);
+#endif // cl_khr_3d_image_writes
+#endif //defined(__opencl_c_read_write_images)
+
+int __ovld get_image_num_mip_levels(read_only image1d_array_t);
+int __ovld get_image_num_mip_levels(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld get_image_num_mip_levels(read_only image2d_array_depth_t);
+int __ovld get_image_num_mip_levels(read_only image2d_depth_t);
+#endif // cl_khr_depth_images
+
+int __ovld get_image_num_mip_levels(write_only image1d_array_t);
+int __ovld get_image_num_mip_levels(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t);
+int __ovld get_image_num_mip_levels(write_only image2d_depth_t);
+#endif // cl_khr_depth_images
+
+#if defined(__opencl_c_read_write_images)
+int __ovld get_image_num_mip_levels(read_write image1d_array_t);
+int __ovld get_image_num_mip_levels(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t);
+int __ovld get_image_num_mip_levels(read_write image2d_depth_t);
+#endif // cl_khr_depth_images
+#endif //defined(__opencl_c_read_write_images)
+
+#endif //cl_khr_mipmap_image
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+/**
+ * Return the channel data type. Valid values are:
+ * CLK_SNORM_INT8
+ * CLK_SNORM_INT16
+ * CLK_UNORM_INT8
+ * CLK_UNORM_INT16
+ * CLK_UNORM_SHORT_565
+ * CLK_UNORM_SHORT_555
+ * CLK_UNORM_SHORT_101010
+ * CLK_SIGNED_INT8
+ * CLK_SIGNED_INT16
+ * CLK_SIGNED_INT32
+ * CLK_UNSIGNED_INT8
+ * CLK_UNSIGNED_INT16
+ * CLK_UNSIGNED_INT32
+ * CLK_HALF_FLOAT
+ * CLK_FLOAT
+ */
+
+int __ovld __cnfn get_image_channel_data_type(read_only image1d_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image1d_buffer_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image3d_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image1d_array_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_depth_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+int __ovld __cnfn get_image_channel_data_type(write_only image1d_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_channel_data_type(write_only image3d_t);
+#endif
+int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_depth_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+#if defined(__opencl_c_read_write_images)
+int __ovld __cnfn get_image_channel_data_type(read_write image1d_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image1d_buffer_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_channel_data_type(read_write image3d_t);
+#endif // cl_khr_3d_image_writes
+int __ovld __cnfn get_image_channel_data_type(read_write image1d_array_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_depth_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_depth_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_t);
+int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+ * Return the image channel order. Valid values are:
+ * CLK_A
+ * CLK_R
+ * CLK_Rx
+ * CLK_RG
+ * CLK_RGx
+ * CLK_RA
+ * CLK_RGB
+ * CLK_RGBx
+ * CLK_RGBA
+ * CLK_ARGB
+ * CLK_BGRA
+ * CLK_INTENSITY
+ * CLK_LUMINANCE
+ */
+
+int __ovld __cnfn get_image_channel_order(read_only image1d_t);
+int __ovld __cnfn get_image_channel_order(read_only image1d_buffer_t);
+int __ovld __cnfn get_image_channel_order(read_only image2d_t);
+int __ovld __cnfn get_image_channel_order(read_only image3d_t);
+int __ovld __cnfn get_image_channel_order(read_only image1d_array_t);
+int __ovld __cnfn get_image_channel_order(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_channel_order(read_only image2d_depth_t);
+int __ovld __cnfn get_image_channel_order(read_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_t);
+int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+int __ovld __cnfn get_image_channel_order(write_only image1d_t);
+int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t);
+int __ovld __cnfn get_image_channel_order(write_only image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_channel_order(write_only image3d_t);
+#endif
+int __ovld __cnfn get_image_channel_order(write_only image1d_array_t);
+int __ovld __cnfn get_image_channel_order(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_channel_order(write_only image2d_depth_t);
+int __ovld __cnfn get_image_channel_order(write_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_t);
+int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+#if defined(__opencl_c_read_write_images)
+int __ovld __cnfn get_image_channel_order(read_write image1d_t);
+int __ovld __cnfn get_image_channel_order(read_write image1d_buffer_t);
+int __ovld __cnfn get_image_channel_order(read_write image2d_t);
+#ifdef cl_khr_3d_image_writes
+int __ovld __cnfn get_image_channel_order(read_write image3d_t);
+#endif // cl_khr_3d_image_writes
+int __ovld __cnfn get_image_channel_order(read_write image1d_array_t);
+int __ovld __cnfn get_image_channel_order(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+int __ovld __cnfn get_image_channel_order(read_write image2d_depth_t);
+int __ovld __cnfn get_image_channel_order(read_write image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_t);
+int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_depth_t);
+int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_t);
+int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+ * Return the 2D image width and height as an int2
+ * type. The width is returned in the x component, and
+ * the height in the y component.
+ */
+int2 __ovld __cnfn get_image_dim(read_only image2d_t);
+int2 __ovld __cnfn get_image_dim(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int2 __ovld __cnfn get_image_dim(read_only image2d_array_depth_t);
+int2 __ovld __cnfn get_image_dim(read_only image2d_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_t);
+int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_depth_t);
+int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_t);
+int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+int2 __ovld __cnfn get_image_dim(write_only image2d_t);
+int2 __ovld __cnfn get_image_dim(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+int2 __ovld __cnfn get_image_dim(write_only image2d_array_depth_t);
+int2 __ovld __cnfn get_image_dim(write_only image2d_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_t);
+int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_depth_t);
+int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_t);
+int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+#if defined(__opencl_c_read_write_images)
+int2 __ovld __cnfn get_image_dim(read_write image2d_t);
+int2 __ovld __cnfn get_image_dim(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+int2 __ovld __cnfn get_image_dim(read_write image2d_array_depth_t);
+int2 __ovld __cnfn get_image_dim(read_write image2d_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_t);
+int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_depth_t);
+int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_t);
+int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+ * Return the 3D image width, height, and depth as an
+ * int4 type. The width is returned in the x
+ * component, height in the y component, depth in the z
+ * component and the w component is 0.
+ */
+int4 __ovld __cnfn get_image_dim(read_only image3d_t);
+#ifdef cl_khr_3d_image_writes
+int4 __ovld __cnfn get_image_dim(write_only image3d_t);
+#if defined(__opencl_c_read_write_images)
+int4 __ovld __cnfn get_image_dim(read_write image3d_t);
+#endif //defined(__opencl_c_read_write_images)
+#endif // cl_khr_3d_image_writes
+
+/**
+ * Return the image array size.
+ */
+
+size_t __ovld __cnfn get_image_array_size(read_only image1d_array_t);
+size_t __ovld __cnfn get_image_array_size(read_only image2d_array_t);
+#ifdef cl_khr_depth_images
+size_t __ovld __cnfn get_image_array_size(read_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_t);
+size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+size_t __ovld __cnfn get_image_array_size(write_only image1d_array_t);
+size_t __ovld __cnfn get_image_array_size(write_only image2d_array_t);
+#ifdef cl_khr_depth_images
+size_t __ovld __cnfn get_image_array_size(write_only image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_t);
+size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+
+#if defined(__opencl_c_read_write_images)
+size_t __ovld __cnfn get_image_array_size(read_write image1d_array_t);
+size_t __ovld __cnfn get_image_array_size(read_write image2d_array_t);
+#ifdef cl_khr_depth_images
+size_t __ovld __cnfn get_image_array_size(read_write image2d_array_depth_t);
+#endif //cl_khr_depth_images
+#if defined(cl_khr_gl_msaa_sharing)
+size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_t);
+size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_depth_t);
+#endif //cl_khr_gl_msaa_sharing
+#endif //defined(__opencl_c_read_write_images)
+
+/**
+* Return the number of samples associated with image
+*/
+#if defined(cl_khr_gl_msaa_sharing)
+int __ovld __cnfn get_image_num_samples(read_only image2d_msaa_t);
+int __ovld __cnfn get_image_num_samples(read_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_num_samples(read_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_num_samples(read_only image2d_array_msaa_depth_t);
+
+int __ovld __cnfn get_image_num_samples(write_only image2d_msaa_t);
+int __ovld __cnfn get_image_num_samples(write_only image2d_msaa_depth_t);
+int __ovld __cnfn get_image_num_samples(write_only image2d_array_msaa_t);
+int __ovld __cnfn get_image_num_samples(write_only image2d_array_msaa_depth_t);
+
+#if defined(__opencl_c_read_write_images)
+int __ovld __cnfn get_image_num_samples(read_write image2d_msaa_t);
+int __ovld __cnfn get_image_num_samples(read_write image2d_msaa_depth_t);
+int __ovld __cnfn get_image_num_samples(read_write image2d_array_msaa_t);
+int __ovld __cnfn get_image_num_samples(read_write image2d_array_msaa_depth_t);
+#endif //defined(__opencl_c_read_write_images)
+#endif
+
+#endif // __opencl_c_images
+
+// OpenCL v2.0 s6.13.15 - Work-group Functions
+
+#if defined(__opencl_c_work_group_collective_functions)
+int __ovld __conv work_group_all(int predicate);
+int __ovld __conv work_group_any(int predicate);
+
+#ifdef cl_khr_fp16
+half __ovld __conv work_group_broadcast(half, size_t local_id);
+half __ovld __conv work_group_broadcast(half, size_t, size_t);
+half __ovld __conv work_group_broadcast(half, size_t, size_t, size_t);
+#endif
+int __ovld __conv work_group_broadcast(int, size_t local_id);
+int __ovld __conv work_group_broadcast(int, size_t, size_t);
+int __ovld __conv work_group_broadcast(int, size_t, size_t, size_t);
+uint __ovld __conv work_group_broadcast(uint, size_t local_id);
+uint __ovld __conv work_group_broadcast(uint, size_t, size_t);
+uint __ovld __conv work_group_broadcast(uint, size_t, size_t, size_t);
+long __ovld __conv work_group_broadcast(long, size_t local_id);
+long __ovld __conv work_group_broadcast(long, size_t, size_t);
+long __ovld __conv work_group_broadcast(long, size_t, size_t, size_t);
+ulong __ovld __conv work_group_broadcast(ulong, size_t local_id);
+ulong __ovld __conv work_group_broadcast(ulong, size_t, size_t);
+ulong __ovld __conv work_group_broadcast(ulong, size_t, size_t, size_t);
+float __ovld __conv work_group_broadcast(float, size_t local_id);
+float __ovld __conv work_group_broadcast(float, size_t, size_t);
+float __ovld __conv work_group_broadcast(float, size_t, size_t, size_t);
+#ifdef cl_khr_fp64
+double __ovld __conv work_group_broadcast(double, size_t local_id);
+double __ovld __conv work_group_broadcast(double, size_t, size_t);
+double __ovld __conv work_group_broadcast(double, size_t, size_t, size_t);
+#endif //cl_khr_fp64
+
+#ifdef cl_khr_fp16
+half __ovld __conv work_group_reduce_add(half);
+half __ovld __conv work_group_reduce_min(half);
+half __ovld __conv work_group_reduce_max(half);
+half __ovld __conv work_group_scan_exclusive_add(half);
+half __ovld __conv work_group_scan_exclusive_min(half);
+half __ovld __conv work_group_scan_exclusive_max(half);
+half __ovld __conv work_group_scan_inclusive_add(half);
+half __ovld __conv work_group_scan_inclusive_min(half);
+half __ovld __conv work_group_scan_inclusive_max(half);
+#endif
+int __ovld __conv work_group_reduce_add(int);
+int __ovld __conv work_group_reduce_min(int);
+int __ovld __conv work_group_reduce_max(int);
+int __ovld __conv work_group_scan_exclusive_add(int);
+int __ovld __conv work_group_scan_exclusive_min(int);
+int __ovld __conv work_group_scan_exclusive_max(int);
+int __ovld __conv work_group_scan_inclusive_add(int);
+int __ovld __conv work_group_scan_inclusive_min(int);
+int __ovld __conv work_group_scan_inclusive_max(int);
+uint __ovld __conv work_group_reduce_add(uint);
+uint __ovld __conv work_group_reduce_min(uint);
+uint __ovld __conv work_group_reduce_max(uint);
+uint __ovld __conv work_group_scan_exclusive_add(uint);
+uint __ovld __conv work_group_scan_exclusive_min(uint);
+uint __ovld __conv work_group_scan_exclusive_max(uint);
+uint __ovld __conv work_group_scan_inclusive_add(uint);
+uint __ovld __conv work_group_scan_inclusive_min(uint);
+uint __ovld __conv work_group_scan_inclusive_max(uint);
+long __ovld __conv work_group_reduce_add(long);
+long __ovld __conv work_group_reduce_min(long);
+long __ovld __conv work_group_reduce_max(long);
+long __ovld __conv work_group_scan_exclusive_add(long);
+long __ovld __conv work_group_scan_exclusive_min(long);
+long __ovld __conv work_group_scan_exclusive_max(long);
+long __ovld __conv work_group_scan_inclusive_add(long);
+long __ovld __conv work_group_scan_inclusive_min(long);
+long __ovld __conv work_group_scan_inclusive_max(long);
+ulong __ovld __conv work_group_reduce_add(ulong);
+ulong __ovld __conv work_group_reduce_min(ulong);
+ulong __ovld __conv work_group_reduce_max(ulong);
+ulong __ovld __conv work_group_scan_exclusive_add(ulong);
+ulong __ovld __conv work_group_scan_exclusive_min(ulong);
+ulong __ovld __conv work_group_scan_exclusive_max(ulong);
+ulong __ovld __conv work_group_scan_inclusive_add(ulong);
+ulong __ovld __conv work_group_scan_inclusive_min(ulong);
+ulong __ovld __conv work_group_scan_inclusive_max(ulong);
+float __ovld __conv work_group_reduce_add(float);
+float __ovld __conv work_group_reduce_min(float);
+float __ovld __conv work_group_reduce_max(float);
+float __ovld __conv work_group_scan_exclusive_add(float);
+float __ovld __conv work_group_scan_exclusive_min(float);
+float __ovld __conv work_group_scan_exclusive_max(float);
+float __ovld __conv work_group_scan_inclusive_add(float);
+float __ovld __conv work_group_scan_inclusive_min(float);
+float __ovld __conv work_group_scan_inclusive_max(float);
+#ifdef cl_khr_fp64
+double __ovld __conv work_group_reduce_add(double);
+double __ovld __conv work_group_reduce_min(double);
+double __ovld __conv work_group_reduce_max(double);
+double __ovld __conv work_group_scan_exclusive_add(double);
+double __ovld __conv work_group_scan_exclusive_min(double);
+double __ovld __conv work_group_scan_exclusive_max(double);
+double __ovld __conv work_group_scan_inclusive_add(double);
+double __ovld __conv work_group_scan_inclusive_min(double);
+double __ovld __conv work_group_scan_inclusive_max(double);
+#endif //cl_khr_fp64
+
+#endif //defined(__opencl_c_work_group_collective_functions)
+
+// OpenCL v2.0 s6.13.16 - Pipe Functions
+#if defined(__opencl_c_pipes)
+bool __ovld is_valid_reserve_id(reserve_id_t reserve_id);
+#endif //defined(__opencl_c_pipes)
+
+
+// OpenCL v2.0 s6.13.17 - Enqueue Kernels
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+#ifdef __opencl_c_device_enqueue
+ndrange_t __ovld ndrange_1D(size_t);
+ndrange_t __ovld ndrange_1D(size_t, size_t);
+ndrange_t __ovld ndrange_1D(size_t, size_t, size_t);
+
+ndrange_t __ovld ndrange_2D(const size_t[2]);
+ndrange_t __ovld ndrange_2D(const size_t[2], const size_t[2]);
+ndrange_t __ovld ndrange_2D(const size_t[2], const size_t[2], const size_t[2]);
+
+ndrange_t __ovld ndrange_3D(const size_t[3]);
+ndrange_t __ovld ndrange_3D(const size_t[3], const size_t[3]);
+ndrange_t __ovld ndrange_3D(const size_t[3], const size_t[3], const size_t[3]);
+
+int __ovld enqueue_marker(queue_t, uint, const clk_event_t*, clk_event_t*);
+
+void __ovld retain_event(clk_event_t);
+
+void __ovld release_event(clk_event_t);
+
+clk_event_t __ovld create_user_event(void);
+
+void __ovld set_user_event_status(clk_event_t e, int state);
+
+bool __ovld is_valid_event (clk_event_t event);
+
+void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void*);
+
+queue_t __ovld get_default_queue(void);
+#endif //__opencl_c_device_enqueue
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+// OpenCL Extension v2.0 s9.17 - Sub-groups
+
+#if defined(__opencl_subgroup_builtins)
+// Shared Sub Group Functions
+uint    __ovld get_sub_group_size(void);
+uint    __ovld get_max_sub_group_size(void);
+uint    __ovld get_num_sub_groups(void);
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+uint    __ovld get_enqueued_num_sub_groups(void);
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+uint    __ovld get_sub_group_id(void);
+uint    __ovld get_sub_group_local_id(void);
+
+void    __ovld __conv sub_group_barrier(cl_mem_fence_flags);
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+void    __ovld __conv sub_group_barrier(cl_mem_fence_flags, memory_scope);
+#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+
+int     __ovld __conv sub_group_all(int predicate);
+int     __ovld __conv sub_group_any(int predicate);
+
+int     __ovld __conv sub_group_broadcast(int  , uint sub_group_local_id);
+uint    __ovld __conv sub_group_broadcast(uint , uint sub_group_local_id);
+long    __ovld __conv sub_group_broadcast(long , uint sub_group_local_id);
+ulong   __ovld __conv sub_group_broadcast(ulong, uint sub_group_local_id);
+float   __ovld __conv sub_group_broadcast(float, uint sub_group_local_id);
+
+int     __ovld __conv sub_group_reduce_add(int  );
+uint    __ovld __conv sub_group_reduce_add(uint );
+long    __ovld __conv sub_group_reduce_add(long );
+ulong   __ovld __conv sub_group_reduce_add(ulong);
+float   __ovld __conv sub_group_reduce_add(float);
+int     __ovld __conv sub_group_reduce_min(int  );
+uint    __ovld __conv sub_group_reduce_min(uint );
+long    __ovld __conv sub_group_reduce_min(long );
+ulong   __ovld __conv sub_group_reduce_min(ulong);
+float   __ovld __conv sub_group_reduce_min(float);
+int     __ovld __conv sub_group_reduce_max(int  );
+uint    __ovld __conv sub_group_reduce_max(uint );
+long    __ovld __conv sub_group_reduce_max(long );
+ulong   __ovld __conv sub_group_reduce_max(ulong);
+float   __ovld __conv sub_group_reduce_max(float);
+
+int     __ovld __conv sub_group_scan_exclusive_add(int  );
+uint    __ovld __conv sub_group_scan_exclusive_add(uint );
+long    __ovld __conv sub_group_scan_exclusive_add(long );
+ulong   __ovld __conv sub_group_scan_exclusive_add(ulong);
+float   __ovld __conv sub_group_scan_exclusive_add(float);
+int     __ovld __conv sub_group_scan_exclusive_min(int  );
+uint    __ovld __conv sub_group_scan_exclusive_min(uint );
+long    __ovld __conv sub_group_scan_exclusive_min(long );
+ulong   __ovld __conv sub_group_scan_exclusive_min(ulong);
+float   __ovld __conv sub_group_scan_exclusive_min(float);
+int     __ovld __conv sub_group_scan_exclusive_max(int  );
+uint    __ovld __conv sub_group_scan_exclusive_max(uint );
+long    __ovld __conv sub_group_scan_exclusive_max(long );
+ulong   __ovld __conv sub_group_scan_exclusive_max(ulong);
+float   __ovld __conv sub_group_scan_exclusive_max(float);
+
+int     __ovld __conv sub_group_scan_inclusive_add(int  );
+uint    __ovld __conv sub_group_scan_inclusive_add(uint );
+long    __ovld __conv sub_group_scan_inclusive_add(long );
+ulong   __ovld __conv sub_group_scan_inclusive_add(ulong);
+float   __ovld __conv sub_group_scan_inclusive_add(float);
+int     __ovld __conv sub_group_scan_inclusive_min(int  );
+uint    __ovld __conv sub_group_scan_inclusive_min(uint );
+long    __ovld __conv sub_group_scan_inclusive_min(long );
+ulong   __ovld __conv sub_group_scan_inclusive_min(ulong);
+float   __ovld __conv sub_group_scan_inclusive_min(float);
+int     __ovld __conv sub_group_scan_inclusive_max(int  );
+uint    __ovld __conv sub_group_scan_inclusive_max(uint );
+long    __ovld __conv sub_group_scan_inclusive_max(long );
+ulong   __ovld __conv sub_group_scan_inclusive_max(ulong);
+float   __ovld __conv sub_group_scan_inclusive_max(float);
+
+#ifdef cl_khr_fp16
+half    __ovld __conv sub_group_broadcast(half, uint sub_group_local_id);
+half    __ovld __conv sub_group_reduce_add(half);
+half    __ovld __conv sub_group_reduce_min(half);
+half    __ovld __conv sub_group_reduce_max(half);
+half    __ovld __conv sub_group_scan_exclusive_add(half);
+half    __ovld __conv sub_group_scan_exclusive_min(half);
+half    __ovld __conv sub_group_scan_exclusive_max(half);
+half    __ovld __conv sub_group_scan_inclusive_add(half);
+half    __ovld __conv sub_group_scan_inclusive_min(half);
+half    __ovld __conv sub_group_scan_inclusive_max(half);
+#endif //cl_khr_fp16
+
+#ifdef cl_khr_fp64
+double  __ovld __conv sub_group_broadcast(double, uint sub_group_local_id);
+double  __ovld __conv sub_group_reduce_add(double);
+double  __ovld __conv sub_group_reduce_min(double);
+double  __ovld __conv sub_group_reduce_max(double);
+double  __ovld __conv sub_group_scan_exclusive_add(double);
+double  __ovld __conv sub_group_scan_exclusive_min(double);
+double  __ovld __conv sub_group_scan_exclusive_max(double);
+double  __ovld __conv sub_group_scan_inclusive_add(double);
+double  __ovld __conv sub_group_scan_inclusive_min(double);
+double  __ovld __conv sub_group_scan_inclusive_max(double);
+#endif //cl_khr_fp64
+
+#endif // __opencl_subgroup_builtins
+
+#if defined(cl_khr_subgroup_extended_types)
+char __ovld __conv sub_group_broadcast( char value, uint index );
+char2 __ovld __conv sub_group_broadcast( char2 value, uint index );
+char3 __ovld __conv sub_group_broadcast( char3 value, uint index );
+char4 __ovld __conv sub_group_broadcast( char4 value, uint index );
+char8 __ovld __conv sub_group_broadcast( char8 value, uint index );
+char16 __ovld __conv sub_group_broadcast( char16 value, uint index );
+
+uchar __ovld __conv sub_group_broadcast( uchar value, uint index );
+uchar2 __ovld __conv sub_group_broadcast( uchar2 value, uint index );
+uchar3 __ovld __conv sub_group_broadcast( uchar3 value, uint index );
+uchar4 __ovld __conv sub_group_broadcast( uchar4 value, uint index );
+uchar8 __ovld __conv sub_group_broadcast( uchar8 value, uint index );
+uchar16 __ovld __conv sub_group_broadcast( uchar16 value, uint index );
+
+short __ovld __conv sub_group_broadcast( short value, uint index );
+short2 __ovld __conv sub_group_broadcast( short2 value, uint index );
+short3 __ovld __conv sub_group_broadcast( short3 value, uint index );
+short4 __ovld __conv sub_group_broadcast( short4 value, uint index );
+short8 __ovld __conv sub_group_broadcast( short8 value, uint index );
+short16 __ovld __conv sub_group_broadcast( short16 value, uint index );
+
+ushort __ovld __conv sub_group_broadcast( ushort value, uint index );
+ushort2 __ovld __conv sub_group_broadcast( ushort2 value, uint index );
+ushort3 __ovld __conv sub_group_broadcast( ushort3 value, uint index );
+ushort4 __ovld __conv sub_group_broadcast( ushort4 value, uint index );
+ushort8 __ovld __conv sub_group_broadcast( ushort8 value, uint index );
+ushort16 __ovld __conv sub_group_broadcast( ushort16 value, uint index );
+
+// scalar int broadcast is part of cl_khr_subgroups
+int2 __ovld __conv sub_group_broadcast( int2 value, uint index );
+int3 __ovld __conv sub_group_broadcast( int3 value, uint index );
+int4 __ovld __conv sub_group_broadcast( int4 value, uint index );
+int8 __ovld __conv sub_group_broadcast( int8 value, uint index );
+int16 __ovld __conv sub_group_broadcast( int16 value, uint index );
+
+// scalar uint broadcast is part of cl_khr_subgroups
+uint2 __ovld __conv sub_group_broadcast( uint2 value, uint index );
+uint3 __ovld __conv sub_group_broadcast( uint3 value, uint index );
+uint4 __ovld __conv sub_group_broadcast( uint4 value, uint index );
+uint8 __ovld __conv sub_group_broadcast( uint8 value, uint index );
+uint16 __ovld __conv sub_group_broadcast( uint16 value, uint index );
+
+// scalar long broadcast is part of cl_khr_subgroups
+long2 __ovld __conv sub_group_broadcast( long2 value, uint index );
+long3 __ovld __conv sub_group_broadcast( long3 value, uint index );
+long4 __ovld __conv sub_group_broadcast( long4 value, uint index );
+long8 __ovld __conv sub_group_broadcast( long8 value, uint index );
+long16 __ovld __conv sub_group_broadcast( long16 value, uint index );
+
+// scalar ulong broadcast is part of cl_khr_subgroups
+ulong2 __ovld __conv sub_group_broadcast( ulong2 value, uint index );
+ulong3 __ovld __conv sub_group_broadcast( ulong3 value, uint index );
+ulong4 __ovld __conv sub_group_broadcast( ulong4 value, uint index );
+ulong8 __ovld __conv sub_group_broadcast( ulong8 value, uint index );
+ulong16 __ovld __conv sub_group_broadcast( ulong16 value, uint index );
+
+// scalar float broadcast is part of cl_khr_subgroups
+float2 __ovld __conv sub_group_broadcast( float2 value, uint index );
+float3 __ovld __conv sub_group_broadcast( float3 value, uint index );
+float4 __ovld __conv sub_group_broadcast( float4 value, uint index );
+float8 __ovld __conv sub_group_broadcast( float8 value, uint index );
+float16 __ovld __conv sub_group_broadcast( float16 value, uint index );
+
+char __ovld __conv sub_group_reduce_add( char value );
+uchar __ovld __conv sub_group_reduce_add( uchar value );
+short __ovld __conv sub_group_reduce_add( short value );
+ushort __ovld __conv sub_group_reduce_add( ushort value );
+
+char __ovld __conv sub_group_reduce_min( char value );
+uchar __ovld __conv sub_group_reduce_min( uchar value );
+short __ovld __conv sub_group_reduce_min( short value );
+ushort __ovld __conv sub_group_reduce_min( ushort value );
+
+char __ovld __conv sub_group_reduce_max( char value );
+uchar __ovld __conv sub_group_reduce_max( uchar value );
+short __ovld __conv sub_group_reduce_max( short value );
+ushort __ovld __conv sub_group_reduce_max( ushort value );
+
+char __ovld __conv sub_group_scan_inclusive_add( char value );
+uchar __ovld __conv sub_group_scan_inclusive_add( uchar value );
+short __ovld __conv sub_group_scan_inclusive_add( short value );
+ushort __ovld __conv sub_group_scan_inclusive_add( ushort value );
+
+char __ovld __conv sub_group_scan_inclusive_min( char value );
+uchar __ovld __conv sub_group_scan_inclusive_min( uchar value );
+short __ovld __conv sub_group_scan_inclusive_min( short value );
+ushort __ovld __conv sub_group_scan_inclusive_min( ushort value );
+
+char __ovld __conv sub_group_scan_inclusive_max( char value );
+uchar __ovld __conv sub_group_scan_inclusive_max( uchar value );
+short __ovld __conv sub_group_scan_inclusive_max( short value );
+ushort __ovld __conv sub_group_scan_inclusive_max( ushort value );
+
+char __ovld __conv sub_group_scan_exclusive_add( char value );
+uchar __ovld __conv sub_group_scan_exclusive_add( uchar value );
+short __ovld __conv sub_group_scan_exclusive_add( short value );
+ushort __ovld __conv sub_group_scan_exclusive_add( ushort value );
+
+char __ovld __conv sub_group_scan_exclusive_min( char value );
+uchar __ovld __conv sub_group_scan_exclusive_min( uchar value );
+short __ovld __conv sub_group_scan_exclusive_min( short value );
+ushort __ovld __conv sub_group_scan_exclusive_min( ushort value );
+
+char __ovld __conv sub_group_scan_exclusive_max( char value );
+uchar __ovld __conv sub_group_scan_exclusive_max( uchar value );
+short __ovld __conv sub_group_scan_exclusive_max( short value );
+ushort __ovld __conv sub_group_scan_exclusive_max( ushort value );
+
+#if defined(cl_khr_fp16)
+// scalar half broadcast is part of cl_khr_subgroups
+half2 __ovld __conv sub_group_broadcast( half2 value, uint index );
+half3 __ovld __conv sub_group_broadcast( half3 value, uint index );
+half4 __ovld __conv sub_group_broadcast( half4 value, uint index );
+half8 __ovld __conv sub_group_broadcast( half8 value, uint index );
+half16 __ovld __conv sub_group_broadcast( half16 value, uint index );
+#endif  // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+// scalar double broadcast is part of cl_khr_subgroups
+double2 __ovld __conv sub_group_broadcast( double2 value, uint index );
+double3 __ovld __conv sub_group_broadcast( double3 value, uint index );
+double4 __ovld __conv sub_group_broadcast( double4 value, uint index );
+double8 __ovld __conv sub_group_broadcast( double8 value, uint index );
+double16 __ovld __conv sub_group_broadcast( double16 value, uint index );
+#endif  // cl_khr_fp64
+
+#endif  // cl_khr_subgroup_extended_types
+
+#if defined(cl_khr_subgroup_non_uniform_vote)
+int     __ovld sub_group_elect(void);
+int     __ovld sub_group_non_uniform_all( int predicate );
+int     __ovld sub_group_non_uniform_any( int predicate );
+
+int     __ovld sub_group_non_uniform_all_equal( char value );
+int     __ovld sub_group_non_uniform_all_equal( uchar value );
+int     __ovld sub_group_non_uniform_all_equal( short value );
+int     __ovld sub_group_non_uniform_all_equal( ushort value );
+int     __ovld sub_group_non_uniform_all_equal( int value );
+int     __ovld sub_group_non_uniform_all_equal( uint value );
+int     __ovld sub_group_non_uniform_all_equal( long value );
+int     __ovld sub_group_non_uniform_all_equal( ulong value );
+int     __ovld sub_group_non_uniform_all_equal( float value );
+
+#if defined(cl_khr_fp16)
+int     __ovld sub_group_non_uniform_all_equal( half value );
+#endif // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+int     __ovld sub_group_non_uniform_all_equal( double value );
+#endif // cl_khr_fp64
+
+#endif // cl_khr_subgroup_non_uniform_vote
+
+#if defined(cl_khr_subgroup_ballot)
+char    __ovld sub_group_non_uniform_broadcast( char value, uint index );
+char2   __ovld sub_group_non_uniform_broadcast( char2 value, uint index );
+char3   __ovld sub_group_non_uniform_broadcast( char3 value, uint index );
+char4   __ovld sub_group_non_uniform_broadcast( char4 value, uint index );
+char8   __ovld sub_group_non_uniform_broadcast( char8 value, uint index );
+char16  __ovld sub_group_non_uniform_broadcast( char16 value, uint index );
+
+uchar   __ovld sub_group_non_uniform_broadcast( uchar value, uint index );
+uchar2  __ovld sub_group_non_uniform_broadcast( uchar2 value, uint index );
+uchar3  __ovld sub_group_non_uniform_broadcast( uchar3 value, uint index );
+uchar4  __ovld sub_group_non_uniform_broadcast( uchar4 value, uint index );
+uchar8  __ovld sub_group_non_uniform_broadcast( uchar8 value, uint index );
+uchar16 __ovld sub_group_non_uniform_broadcast( uchar16 value, uint index );
+
+short   __ovld sub_group_non_uniform_broadcast( short value, uint index );
+short2  __ovld sub_group_non_uniform_broadcast( short2 value, uint index );
+short3  __ovld sub_group_non_uniform_broadcast( short3 value, uint index );
+short4  __ovld sub_group_non_uniform_broadcast( short4 value, uint index );
+short8  __ovld sub_group_non_uniform_broadcast( short8 value, uint index );
+short16 __ovld sub_group_non_uniform_broadcast( short16 value, uint index );
+
+ushort  __ovld sub_group_non_uniform_broadcast( ushort value, uint index );
+ushort2 __ovld sub_group_non_uniform_broadcast( ushort2 value, uint index );
+ushort3 __ovld sub_group_non_uniform_broadcast( ushort3 value, uint index );
+ushort4 __ovld sub_group_non_uniform_broadcast( ushort4 value, uint index );
+ushort8 __ovld sub_group_non_uniform_broadcast( ushort8 value, uint index );
+ushort16 __ovld sub_group_non_uniform_broadcast( ushort16 value, uint index );
+
+int     __ovld sub_group_non_uniform_broadcast( int value, uint index );
+int2    __ovld sub_group_non_uniform_broadcast( int2 value, uint index );
+int3    __ovld sub_group_non_uniform_broadcast( int3 value, uint index );
+int4    __ovld sub_group_non_uniform_broadcast( int4 value, uint index );
+int8    __ovld sub_group_non_uniform_broadcast( int8 value, uint index );
+int16   __ovld sub_group_non_uniform_broadcast( int16 value, uint index );
+
+uint    __ovld sub_group_non_uniform_broadcast( uint value, uint index );
+uint2   __ovld sub_group_non_uniform_broadcast( uint2 value, uint index );
+uint3   __ovld sub_group_non_uniform_broadcast( uint3 value, uint index );
+uint4   __ovld sub_group_non_uniform_broadcast( uint4 value, uint index );
+uint8   __ovld sub_group_non_uniform_broadcast( uint8 value, uint index );
+uint16  __ovld sub_group_non_uniform_broadcast( uint16 value, uint index );
+
+long    __ovld sub_group_non_uniform_broadcast( long value, uint index );
+long2   __ovld sub_group_non_uniform_broadcast( long2 value, uint index );
+long3   __ovld sub_group_non_uniform_broadcast( long3 value, uint index );
+long4   __ovld sub_group_non_uniform_broadcast( long4 value, uint index );
+long8   __ovld sub_group_non_uniform_broadcast( long8 value, uint index );
+long16  __ovld sub_group_non_uniform_broadcast( long16 value, uint index );
+
+ulong   __ovld sub_group_non_uniform_broadcast( ulong value, uint index );
+ulong2  __ovld sub_group_non_uniform_broadcast( ulong2 value, uint index );
+ulong3  __ovld sub_group_non_uniform_broadcast( ulong3 value, uint index );
+ulong4  __ovld sub_group_non_uniform_broadcast( ulong4 value, uint index );
+ulong8  __ovld sub_group_non_uniform_broadcast( ulong8 value, uint index );
+ulong16 __ovld sub_group_non_uniform_broadcast( ulong16 value, uint index );
+
+float   __ovld sub_group_non_uniform_broadcast( float value, uint index );
+float2  __ovld sub_group_non_uniform_broadcast( float2 value, uint index );
+float3  __ovld sub_group_non_uniform_broadcast( float3 value, uint index );
+float4  __ovld sub_group_non_uniform_broadcast( float4 value, uint index );
+float8  __ovld sub_group_non_uniform_broadcast( float8 value, uint index );
+float16 __ovld sub_group_non_uniform_broadcast( float16 value, uint index );
+
+char    __ovld sub_group_broadcast_first( char value );
+uchar   __ovld sub_group_broadcast_first( uchar value );
+short   __ovld sub_group_broadcast_first( short value );
+ushort  __ovld sub_group_broadcast_first( ushort value );
+int     __ovld sub_group_broadcast_first( int value );
+uint    __ovld sub_group_broadcast_first( uint value );
+long    __ovld sub_group_broadcast_first( long value );
+ulong   __ovld sub_group_broadcast_first( ulong value );
+float   __ovld sub_group_broadcast_first( float value );
+
+uint4   __ovld sub_group_ballot( int predicate );
+int     __ovld __cnfn sub_group_inverse_ballot( uint4 value );
+int     __ovld __cnfn sub_group_ballot_bit_extract( uint4 value, uint index );
+uint    __ovld __cnfn sub_group_ballot_bit_count( uint4 value );
+
+uint    __ovld sub_group_ballot_inclusive_scan( uint4 value );
+uint    __ovld sub_group_ballot_exclusive_scan( uint4 value );
+uint    __ovld sub_group_ballot_find_lsb( uint4 value );
+uint    __ovld sub_group_ballot_find_msb( uint4 value );
+
+uint4   __ovld __cnfn get_sub_group_eq_mask(void);
+uint4   __ovld __cnfn get_sub_group_ge_mask(void);
+uint4   __ovld __cnfn get_sub_group_gt_mask(void);
+uint4   __ovld __cnfn get_sub_group_le_mask(void);
+uint4   __ovld __cnfn get_sub_group_lt_mask(void);
+
+#if defined(cl_khr_fp16)
+half    __ovld sub_group_non_uniform_broadcast( half value, uint index );
+half2   __ovld sub_group_non_uniform_broadcast( half2 value, uint index );
+half3   __ovld sub_group_non_uniform_broadcast( half3 value, uint index );
+half4   __ovld sub_group_non_uniform_broadcast( half4 value, uint index );
+half8   __ovld sub_group_non_uniform_broadcast( half8 value, uint index );
+half16  __ovld sub_group_non_uniform_broadcast( half16 value, uint index );
+
+half    __ovld sub_group_broadcast_first( half value );
+#endif // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+double   __ovld sub_group_non_uniform_broadcast( double value, uint index );
+double2  __ovld sub_group_non_uniform_broadcast( double2 value, uint index );
+double3  __ovld sub_group_non_uniform_broadcast( double3 value, uint index );
+double4  __ovld sub_group_non_uniform_broadcast( double4 value, uint index );
+double8  __ovld sub_group_non_uniform_broadcast( double8 value, uint index );
+double16 __ovld sub_group_non_uniform_broadcast( double16 value, uint index );
+
+double   __ovld sub_group_broadcast_first( double value );
+#endif // cl_khr_fp64
+
+#endif // cl_khr_subgroup_ballot
+
+#if defined(cl_khr_subgroup_non_uniform_arithmetic)
+char    __ovld sub_group_non_uniform_reduce_add( char value );
+uchar   __ovld sub_group_non_uniform_reduce_add( uchar value );
+short   __ovld sub_group_non_uniform_reduce_add( short value );
+ushort  __ovld sub_group_non_uniform_reduce_add( ushort value );
+int     __ovld sub_group_non_uniform_reduce_add( int value );
+uint    __ovld sub_group_non_uniform_reduce_add( uint value );
+long    __ovld sub_group_non_uniform_reduce_add( long value );
+ulong   __ovld sub_group_non_uniform_reduce_add( ulong value );
+float   __ovld sub_group_non_uniform_reduce_add( float value );
+
+char    __ovld sub_group_non_uniform_reduce_mul( char value );
+uchar   __ovld sub_group_non_uniform_reduce_mul( uchar value );
+short   __ovld sub_group_non_uniform_reduce_mul( short value );
+ushort  __ovld sub_group_non_uniform_reduce_mul( ushort value );
+int     __ovld sub_group_non_uniform_reduce_mul( int value );
+uint    __ovld sub_group_non_uniform_reduce_mul( uint value );
+long    __ovld sub_group_non_uniform_reduce_mul( long value );
+ulong   __ovld sub_group_non_uniform_reduce_mul( ulong value );
+float   __ovld sub_group_non_uniform_reduce_mul( float value );
+
+char    __ovld sub_group_non_uniform_reduce_min( char value );
+uchar   __ovld sub_group_non_uniform_reduce_min( uchar value );
+short   __ovld sub_group_non_uniform_reduce_min( short value );
+ushort  __ovld sub_group_non_uniform_reduce_min( ushort value );
+int     __ovld sub_group_non_uniform_reduce_min( int value );
+uint    __ovld sub_group_non_uniform_reduce_min( uint value );
+long    __ovld sub_group_non_uniform_reduce_min( long value );
+ulong   __ovld sub_group_non_uniform_reduce_min( ulong value );
+float   __ovld sub_group_non_uniform_reduce_min( float value );
+
+char    __ovld sub_group_non_uniform_reduce_max( char value );
+uchar   __ovld sub_group_non_uniform_reduce_max( uchar value );
+short   __ovld sub_group_non_uniform_reduce_max( short value );
+ushort  __ovld sub_group_non_uniform_reduce_max( ushort value );
+int     __ovld sub_group_non_uniform_reduce_max( int value );
+uint    __ovld sub_group_non_uniform_reduce_max( uint value );
+long    __ovld sub_group_non_uniform_reduce_max( long value );
+ulong   __ovld sub_group_non_uniform_reduce_max( ulong value );
+float   __ovld sub_group_non_uniform_reduce_max( float value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_add( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_add( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_add( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_add( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_add( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_add( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_add( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_add( ulong value );
+float   __ovld sub_group_non_uniform_scan_inclusive_add( float value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_mul( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_mul( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_mul( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_mul( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_mul( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_mul( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_mul( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_mul( ulong value );
+float   __ovld sub_group_non_uniform_scan_inclusive_mul( float value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_min( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_min( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_min( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_min( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_min( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_min( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_min( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_min( ulong value );
+float   __ovld sub_group_non_uniform_scan_inclusive_min( float value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_max( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_max( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_max( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_max( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_max( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_max( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_max( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_max( ulong value );
+float   __ovld sub_group_non_uniform_scan_inclusive_max( float value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_add( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_add( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_add( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_add( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_add( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_add( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_add( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_add( ulong value );
+float   __ovld sub_group_non_uniform_scan_exclusive_add( float value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_mul( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_mul( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_mul( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_mul( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_mul( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_mul( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_mul( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_mul( ulong value );
+float   __ovld sub_group_non_uniform_scan_exclusive_mul( float value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_min( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_min( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_min( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_min( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_min( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_min( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_min( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_min( ulong value );
+float   __ovld sub_group_non_uniform_scan_exclusive_min( float value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_max( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_max( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_max( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_max( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_max( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_max( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_max( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_max( ulong value );
+float   __ovld sub_group_non_uniform_scan_exclusive_max( float value );
+
+char    __ovld sub_group_non_uniform_reduce_and( char value );
+uchar   __ovld sub_group_non_uniform_reduce_and( uchar value );
+short   __ovld sub_group_non_uniform_reduce_and( short value );
+ushort  __ovld sub_group_non_uniform_reduce_and( ushort value );
+int     __ovld sub_group_non_uniform_reduce_and( int value );
+uint    __ovld sub_group_non_uniform_reduce_and( uint value );
+long    __ovld sub_group_non_uniform_reduce_and( long value );
+ulong   __ovld sub_group_non_uniform_reduce_and( ulong value );
+
+char    __ovld sub_group_non_uniform_reduce_or( char value );
+uchar   __ovld sub_group_non_uniform_reduce_or( uchar value );
+short   __ovld sub_group_non_uniform_reduce_or( short value );
+ushort  __ovld sub_group_non_uniform_reduce_or( ushort value );
+int     __ovld sub_group_non_uniform_reduce_or( int value );
+uint    __ovld sub_group_non_uniform_reduce_or( uint value );
+long    __ovld sub_group_non_uniform_reduce_or( long value );
+ulong   __ovld sub_group_non_uniform_reduce_or( ulong value );
+
+char    __ovld sub_group_non_uniform_reduce_xor( char value );
+uchar   __ovld sub_group_non_uniform_reduce_xor( uchar value );
+short   __ovld sub_group_non_uniform_reduce_xor( short value );
+ushort  __ovld sub_group_non_uniform_reduce_xor( ushort value );
+int     __ovld sub_group_non_uniform_reduce_xor( int value );
+uint    __ovld sub_group_non_uniform_reduce_xor( uint value );
+long    __ovld sub_group_non_uniform_reduce_xor( long value );
+ulong   __ovld sub_group_non_uniform_reduce_xor( ulong value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_and( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_and( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_and( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_and( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_and( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_and( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_and( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_and( ulong value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_or( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_or( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_or( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_or( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_or( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_or( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_or( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_or( ulong value );
+
+char    __ovld sub_group_non_uniform_scan_inclusive_xor( char value );
+uchar   __ovld sub_group_non_uniform_scan_inclusive_xor( uchar value );
+short   __ovld sub_group_non_uniform_scan_inclusive_xor( short value );
+ushort  __ovld sub_group_non_uniform_scan_inclusive_xor( ushort value );
+int     __ovld sub_group_non_uniform_scan_inclusive_xor( int value );
+uint    __ovld sub_group_non_uniform_scan_inclusive_xor( uint value );
+long    __ovld sub_group_non_uniform_scan_inclusive_xor( long value );
+ulong   __ovld sub_group_non_uniform_scan_inclusive_xor( ulong value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_and( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_and( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_and( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_and( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_and( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_and( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_and( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_and( ulong value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_or( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_or( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_or( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_or( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_or( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_or( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_or( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_or( ulong value );
+
+char    __ovld sub_group_non_uniform_scan_exclusive_xor( char value );
+uchar   __ovld sub_group_non_uniform_scan_exclusive_xor( uchar value );
+short   __ovld sub_group_non_uniform_scan_exclusive_xor( short value );
+ushort  __ovld sub_group_non_uniform_scan_exclusive_xor( ushort value );
+int     __ovld sub_group_non_uniform_scan_exclusive_xor( int value );
+uint    __ovld sub_group_non_uniform_scan_exclusive_xor( uint value );
+long    __ovld sub_group_non_uniform_scan_exclusive_xor( long value );
+ulong   __ovld sub_group_non_uniform_scan_exclusive_xor( ulong value );
+
+int     __ovld sub_group_non_uniform_reduce_logical_and( int predicate );
+int     __ovld sub_group_non_uniform_reduce_logical_or( int predicate );
+int     __ovld sub_group_non_uniform_reduce_logical_xor( int predicate );
+
+int     __ovld sub_group_non_uniform_scan_inclusive_logical_and( int predicate );
+int     __ovld sub_group_non_uniform_scan_inclusive_logical_or( int predicate );
+int     __ovld sub_group_non_uniform_scan_inclusive_logical_xor( int predicate );
+
+int     __ovld sub_group_non_uniform_scan_exclusive_logical_and( int predicate );
+int     __ovld sub_group_non_uniform_scan_exclusive_logical_or( int predicate );
+int     __ovld sub_group_non_uniform_scan_exclusive_logical_xor( int predicate );
+
+#if defined(cl_khr_fp16)
+half    __ovld sub_group_non_uniform_reduce_add( half value );
+half    __ovld sub_group_non_uniform_reduce_mul( half value );
+half    __ovld sub_group_non_uniform_reduce_min( half value );
+half    __ovld sub_group_non_uniform_reduce_max( half value );
+half    __ovld sub_group_non_uniform_scan_inclusive_add( half value );
+half    __ovld sub_group_non_uniform_scan_inclusive_mul( half value );
+half    __ovld sub_group_non_uniform_scan_inclusive_min( half value );
+half    __ovld sub_group_non_uniform_scan_inclusive_max( half value );
+half    __ovld sub_group_non_uniform_scan_exclusive_add( half value );
+half    __ovld sub_group_non_uniform_scan_exclusive_mul( half value );
+half    __ovld sub_group_non_uniform_scan_exclusive_min( half value );
+half    __ovld sub_group_non_uniform_scan_exclusive_max( half value );
+#endif // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+double  __ovld sub_group_non_uniform_reduce_add( double value );
+double  __ovld sub_group_non_uniform_reduce_mul( double value );
+double  __ovld sub_group_non_uniform_reduce_min( double value );
+double  __ovld sub_group_non_uniform_reduce_max( double value );
+double  __ovld sub_group_non_uniform_scan_inclusive_add( double value );
+double  __ovld sub_group_non_uniform_scan_inclusive_mul( double value );
+double  __ovld sub_group_non_uniform_scan_inclusive_min( double value );
+double  __ovld sub_group_non_uniform_scan_inclusive_max( double value );
+double  __ovld sub_group_non_uniform_scan_exclusive_add( double value );
+double  __ovld sub_group_non_uniform_scan_exclusive_mul( double value );
+double  __ovld sub_group_non_uniform_scan_exclusive_min( double value );
+double  __ovld sub_group_non_uniform_scan_exclusive_max( double value );
+#endif // cl_khr_fp64
+
+#endif // cl_khr_subgroup_non_uniform_arithmetic
+
+#if defined(cl_khr_subgroup_shuffle)
+char    __ovld sub_group_shuffle( char value, uint index );
+uchar   __ovld sub_group_shuffle( uchar value, uint index );
+short   __ovld sub_group_shuffle( short value, uint index );
+ushort  __ovld sub_group_shuffle( ushort value, uint index );
+int     __ovld sub_group_shuffle( int value, uint index );
+uint    __ovld sub_group_shuffle( uint value, uint index );
+long    __ovld sub_group_shuffle( long value, uint index );
+ulong   __ovld sub_group_shuffle( ulong value, uint index );
+float   __ovld sub_group_shuffle( float value, uint index );
+
+char    __ovld sub_group_shuffle_xor( char value, uint mask );
+uchar   __ovld sub_group_shuffle_xor( uchar value, uint mask );
+short   __ovld sub_group_shuffle_xor( short value, uint mask );
+ushort  __ovld sub_group_shuffle_xor( ushort value, uint mask );
+int     __ovld sub_group_shuffle_xor( int value, uint mask );
+uint    __ovld sub_group_shuffle_xor( uint value, uint mask );
+long    __ovld sub_group_shuffle_xor( long value, uint mask );
+ulong   __ovld sub_group_shuffle_xor( ulong value, uint mask );
+float   __ovld sub_group_shuffle_xor( float value, uint mask );
+
+#if defined(cl_khr_fp16)
+half    __ovld sub_group_shuffle( half value, uint index );
+half    __ovld sub_group_shuffle_xor( half value, uint mask );
+#endif // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+double  __ovld sub_group_shuffle( double value, uint index );
+double  __ovld sub_group_shuffle_xor( double value, uint mask );
+#endif // cl_khr_fp64
+
+#endif // cl_khr_subgroup_shuffle
+
+#if defined(cl_khr_subgroup_shuffle_relative)
+char    __ovld sub_group_shuffle_up( char value, uint delta );
+uchar   __ovld sub_group_shuffle_up( uchar value, uint delta );
+short   __ovld sub_group_shuffle_up( short value, uint delta );
+ushort  __ovld sub_group_shuffle_up( ushort value, uint delta );
+int     __ovld sub_group_shuffle_up( int value, uint delta );
+uint    __ovld sub_group_shuffle_up( uint value, uint delta );
+long    __ovld sub_group_shuffle_up( long value, uint delta );
+ulong   __ovld sub_group_shuffle_up( ulong value, uint delta );
+float   __ovld sub_group_shuffle_up( float value, uint delta );
+
+char    __ovld sub_group_shuffle_down( char value, uint delta );
+uchar   __ovld sub_group_shuffle_down( uchar value, uint delta );
+short   __ovld sub_group_shuffle_down( short value, uint delta );
+ushort  __ovld sub_group_shuffle_down( ushort value, uint delta );
+int     __ovld sub_group_shuffle_down( int value, uint delta );
+uint    __ovld sub_group_shuffle_down( uint value, uint delta );
+long    __ovld sub_group_shuffle_down( long value, uint delta );
+ulong   __ovld sub_group_shuffle_down( ulong value, uint delta );
+float   __ovld sub_group_shuffle_down( float value, uint delta );
+
+#if defined(cl_khr_fp16)
+half    __ovld sub_group_shuffle_up( half value, uint delta );
+half    __ovld sub_group_shuffle_down( half value, uint delta );
+#endif // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+double  __ovld sub_group_shuffle_up( double value, uint delta );
+double  __ovld sub_group_shuffle_down( double value, uint delta );
+#endif // cl_khr_fp64
+
+#endif // cl_khr_subgroup_shuffle_relative
+
+#if defined(cl_khr_subgroup_clustered_reduce)
+char    __ovld sub_group_clustered_reduce_add( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_add( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_add( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_add( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_add( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_add( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_add( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_add( ulong value, uint clustersize );
+float   __ovld sub_group_clustered_reduce_add( float value, uint clustersize );
+
+char    __ovld sub_group_clustered_reduce_mul( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_mul( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_mul( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_mul( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_mul( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_mul( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_mul( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_mul( ulong value, uint clustersize );
+float   __ovld sub_group_clustered_reduce_mul( float value, uint clustersize );
+
+char    __ovld sub_group_clustered_reduce_min( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_min( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_min( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_min( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_min( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_min( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_min( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_min( ulong value, uint clustersize );
+float   __ovld sub_group_clustered_reduce_min( float value, uint clustersize );
+
+char    __ovld sub_group_clustered_reduce_max( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_max( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_max( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_max( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_max( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_max( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_max( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_max( ulong value, uint clustersize );
+float   __ovld sub_group_clustered_reduce_max( float value, uint clustersize );
+
+char    __ovld sub_group_clustered_reduce_and( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_and( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_and( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_and( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_and( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_and( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_and( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_and( ulong value, uint clustersize );
+
+char    __ovld sub_group_clustered_reduce_or( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_or( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_or( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_or( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_or( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_or( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_or( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_or( ulong value, uint clustersize );
+
+char    __ovld sub_group_clustered_reduce_xor( char value, uint clustersize );
+uchar   __ovld sub_group_clustered_reduce_xor( uchar value, uint clustersize );
+short   __ovld sub_group_clustered_reduce_xor( short value, uint clustersize );
+ushort  __ovld sub_group_clustered_reduce_xor( ushort value, uint clustersize );
+int     __ovld sub_group_clustered_reduce_xor( int value, uint clustersize );
+uint    __ovld sub_group_clustered_reduce_xor( uint value, uint clustersize );
+long    __ovld sub_group_clustered_reduce_xor( long value, uint clustersize );
+ulong   __ovld sub_group_clustered_reduce_xor( ulong value, uint clustersize );
+
+int     __ovld sub_group_clustered_reduce_logical_and( int predicate, uint clustersize );
+int     __ovld sub_group_clustered_reduce_logical_or( int predicate, uint clustersize );
+int     __ovld sub_group_clustered_reduce_logical_xor( int predicate, uint clustersize );
+
+#if defined(cl_khr_fp16)
+half    __ovld sub_group_clustered_reduce_add( half value, uint clustersize );
+half    __ovld sub_group_clustered_reduce_mul( half value, uint clustersize );
+half    __ovld sub_group_clustered_reduce_min( half value, uint clustersize );
+half    __ovld sub_group_clustered_reduce_max( half value, uint clustersize );
+#endif // cl_khr_fp16
+
+#if defined(cl_khr_fp64)
+double  __ovld sub_group_clustered_reduce_add( double value, uint clustersize );
+double  __ovld sub_group_clustered_reduce_mul( double value, uint clustersize );
+double  __ovld sub_group_clustered_reduce_min( double value, uint clustersize );
+double  __ovld sub_group_clustered_reduce_max( double value, uint clustersize );
+#endif // cl_khr_fp64
+
+#endif // cl_khr_subgroup_clustered_reduce
+
+#if defined(cl_khr_extended_bit_ops)
+char __ovld __cnfn bitfield_insert(char, char, uint, uint);
+uchar __ovld __cnfn bitfield_insert(uchar, uchar, uint, uint);
+short __ovld __cnfn bitfield_insert(short, short, uint, uint);
+ushort __ovld __cnfn bitfield_insert(ushort, ushort, uint, uint);
+int __ovld __cnfn bitfield_insert(int, int, uint, uint);
+uint __ovld __cnfn bitfield_insert(uint, uint, uint, uint);
+long __ovld __cnfn bitfield_insert(long, long, uint, uint);
+ulong __ovld __cnfn bitfield_insert(ulong, ulong, uint, uint);
+char2 __ovld __cnfn bitfield_insert(char2, char2, uint, uint);
+uchar2 __ovld __cnfn bitfield_insert(uchar2, uchar2, uint, uint);
+short2 __ovld __cnfn bitfield_insert(short2, short2, uint, uint);
+ushort2 __ovld __cnfn bitfield_insert(ushort2, ushort2, uint, uint);
+int2 __ovld __cnfn bitfield_insert(int2, int2, uint, uint);
+uint2 __ovld __cnfn bitfield_insert(uint2, uint2, uint, uint);
+long2 __ovld __cnfn bitfield_insert(long2, long2, uint, uint);
+ulong2 __ovld __cnfn bitfield_insert(ulong2, ulong2, uint, uint);
+char3 __ovld __cnfn bitfield_insert(char3, char3, uint, uint);
+uchar3 __ovld __cnfn bitfield_insert(uchar3, uchar3, uint, uint);
+short3 __ovld __cnfn bitfield_insert(short3, short3, uint, uint);
+ushort3 __ovld __cnfn bitfield_insert(ushort3, ushort3, uint, uint);
+int3 __ovld __cnfn bitfield_insert(int3, int3, uint, uint);
+uint3 __ovld __cnfn bitfield_insert(uint3, uint3, uint, uint);
+long3 __ovld __cnfn bitfield_insert(long3, long3, uint, uint);
+ulong3 __ovld __cnfn bitfield_insert(ulong3, ulong3, uint, uint);
+char4 __ovld __cnfn bitfield_insert(char4, char4, uint, uint);
+uchar4 __ovld __cnfn bitfield_insert(uchar4, uchar4, uint, uint);
+short4 __ovld __cnfn bitfield_insert(short4, short4, uint, uint);
+ushort4 __ovld __cnfn bitfield_insert(ushort4, ushort4, uint, uint);
+int4 __ovld __cnfn bitfield_insert(int4, int4, uint, uint);
+uint4 __ovld __cnfn bitfield_insert(uint4, uint4, uint, uint);
+long4 __ovld __cnfn bitfield_insert(long4, long4, uint, uint);
+ulong4 __ovld __cnfn bitfield_insert(ulong4, ulong4, uint, uint);
+char8 __ovld __cnfn bitfield_insert(char8, char8, uint, uint);
+uchar8 __ovld __cnfn bitfield_insert(uchar8, uchar8, uint, uint);
+short8 __ovld __cnfn bitfield_insert(short8, short8, uint, uint);
+ushort8 __ovld __cnfn bitfield_insert(ushort8, ushort8, uint, uint);
+int8 __ovld __cnfn bitfield_insert(int8, int8, uint, uint);
+uint8 __ovld __cnfn bitfield_insert(uint8, uint8, uint, uint);
+long8 __ovld __cnfn bitfield_insert(long8, long8, uint, uint);
+ulong8 __ovld __cnfn bitfield_insert(ulong8, ulong8, uint, uint);
+char16 __ovld __cnfn bitfield_insert(char16, char16, uint, uint);
+uchar16 __ovld __cnfn bitfield_insert(uchar16, uchar16, uint, uint);
+short16 __ovld __cnfn bitfield_insert(short16, short16, uint, uint);
+ushort16 __ovld __cnfn bitfield_insert(ushort16, ushort16, uint, uint);
+int16 __ovld __cnfn bitfield_insert(int16, int16, uint, uint);
+uint16 __ovld __cnfn bitfield_insert(uint16, uint16, uint, uint);
+long16 __ovld __cnfn bitfield_insert(long16, long16, uint, uint);
+ulong16 __ovld __cnfn bitfield_insert(ulong16, ulong16, uint, uint);
+
+char __ovld __cnfn bitfield_extract_signed(char, uint, uint);
+short __ovld __cnfn bitfield_extract_signed(short, uint, uint);
+int __ovld __cnfn bitfield_extract_signed(int, uint, uint);
+long __ovld __cnfn bitfield_extract_signed(long, uint, uint);
+char2 __ovld __cnfn bitfield_extract_signed(char2, uint, uint);
+short2 __ovld __cnfn bitfield_extract_signed(short2, uint, uint);
+int2 __ovld __cnfn bitfield_extract_signed(int2, uint, uint);
+long2 __ovld __cnfn bitfield_extract_signed(long2, uint, uint);
+char3 __ovld __cnfn bitfield_extract_signed(char3, uint, uint);
+short3 __ovld __cnfn bitfield_extract_signed(short3, uint, uint);
+int3 __ovld __cnfn bitfield_extract_signed(int3, uint, uint);
+long3 __ovld __cnfn bitfield_extract_signed(long3, uint, uint);
+char4 __ovld __cnfn bitfield_extract_signed(char4, uint, uint);
+short4 __ovld __cnfn bitfield_extract_signed(short4, uint, uint);
+int4 __ovld __cnfn bitfield_extract_signed(int4, uint, uint);
+long4 __ovld __cnfn bitfield_extract_signed(long4, uint, uint);
+char8 __ovld __cnfn bitfield_extract_signed(char8, uint, uint);
+short8 __ovld __cnfn bitfield_extract_signed(short8, uint, uint);
+int8 __ovld __cnfn bitfield_extract_signed(int8, uint, uint);
+long8 __ovld __cnfn bitfield_extract_signed(long8, uint, uint);
+char16 __ovld __cnfn bitfield_extract_signed(char16, uint, uint);
+short16 __ovld __cnfn bitfield_extract_signed(short16, uint, uint);
+int16 __ovld __cnfn bitfield_extract_signed(int16, uint, uint);
+long16 __ovld __cnfn bitfield_extract_signed(long16, uint, uint);
+
+char __ovld __cnfn bitfield_extract_signed(uchar, uint, uint);
+short __ovld __cnfn bitfield_extract_signed(ushort, uint, uint);
+int __ovld __cnfn bitfield_extract_signed(uint, uint, uint);
+long __ovld __cnfn bitfield_extract_signed(ulong, uint, uint);
+char2 __ovld __cnfn bitfield_extract_signed(uchar2, uint, uint);
+short2 __ovld __cnfn bitfield_extract_signed(ushort2, uint, uint);
+int2 __ovld __cnfn bitfield_extract_signed(uint2, uint, uint);
+long2 __ovld __cnfn bitfield_extract_signed(ulong2, uint, uint);
+char3 __ovld __cnfn bitfield_extract_signed(uchar3, uint, uint);
+short3 __ovld __cnfn bitfield_extract_signed(ushort3, uint, uint);
+int3 __ovld __cnfn bitfield_extract_signed(uint3, uint, uint);
+long3 __ovld __cnfn bitfield_extract_signed(ulong3, uint, uint);
+char4 __ovld __cnfn bitfield_extract_signed(uchar4, uint, uint);
+short4 __ovld __cnfn bitfield_extract_signed(ushort4, uint, uint);
+int4 __ovld __cnfn bitfield_extract_signed(uint4, uint, uint);
+long4 __ovld __cnfn bitfield_extract_signed(ulong4, uint, uint);
+char8 __ovld __cnfn bitfield_extract_signed(uchar8, uint, uint);
+short8 __ovld __cnfn bitfield_extract_signed(ushort8, uint, uint);
+int8 __ovld __cnfn bitfield_extract_signed(uint8, uint, uint);
+long8 __ovld __cnfn bitfield_extract_signed(ulong8, uint, uint);
+char16 __ovld __cnfn bitfield_extract_signed(uchar16, uint, uint);
+short16 __ovld __cnfn bitfield_extract_signed(ushort16, uint, uint);
+int16 __ovld __cnfn bitfield_extract_signed(uint16, uint, uint);
+long16 __ovld __cnfn bitfield_extract_signed(ulong16, uint, uint);
+
+uchar __ovld __cnfn bitfield_extract_unsigned(char, uint, uint);
+ushort __ovld __cnfn bitfield_extract_unsigned(short, uint, uint);
+uint __ovld __cnfn bitfield_extract_unsigned(int, uint, uint);
+ulong __ovld __cnfn bitfield_extract_unsigned(long, uint, uint);
+uchar2 __ovld __cnfn bitfield_extract_unsigned(char2, uint, uint);
+ushort2 __ovld __cnfn bitfield_extract_unsigned(short2, uint, uint);
+uint2 __ovld __cnfn bitfield_extract_unsigned(int2, uint, uint);
+ulong2 __ovld __cnfn bitfield_extract_unsigned(long2, uint, uint);
+uchar3 __ovld __cnfn bitfield_extract_unsigned(char3, uint, uint);
+ushort3 __ovld __cnfn bitfield_extract_unsigned(short3, uint, uint);
+uint3 __ovld __cnfn bitfield_extract_unsigned(int3, uint, uint);
+ulong3 __ovld __cnfn bitfield_extract_unsigned(long3, uint, uint);
+uchar4 __ovld __cnfn bitfield_extract_unsigned(char4, uint, uint);
+ushort4 __ovld __cnfn bitfield_extract_unsigned(short4, uint, uint);
+uint4 __ovld __cnfn bitfield_extract_unsigned(int4, uint, uint);
+ulong4 __ovld __cnfn bitfield_extract_unsigned(long4, uint, uint);
+uchar8 __ovld __cnfn bitfield_extract_unsigned(char8, uint, uint);
+ushort8 __ovld __cnfn bitfield_extract_unsigned(short8, uint, uint);
+uint8 __ovld __cnfn bitfield_extract_unsigned(int8, uint, uint);
+ulong8 __ovld __cnfn bitfield_extract_unsigned(long8, uint, uint);
+uchar16 __ovld __cnfn bitfield_extract_unsigned(char16, uint, uint);
+ushort16 __ovld __cnfn bitfield_extract_unsigned(short16, uint, uint);
+uint16 __ovld __cnfn bitfield_extract_unsigned(int16, uint, uint);
+ulong16 __ovld __cnfn bitfield_extract_unsigned(long16, uint, uint);
+
+uchar __ovld __cnfn bitfield_extract_unsigned(uchar, uint, uint);
+ushort __ovld __cnfn bitfield_extract_unsigned(ushort, uint, uint);
+uint __ovld __cnfn bitfield_extract_unsigned(uint, uint, uint);
+ulong __ovld __cnfn bitfield_extract_unsigned(ulong, uint, uint);
+uchar2 __ovld __cnfn bitfield_extract_unsigned(uchar2, uint, uint);
+ushort2 __ovld __cnfn bitfield_extract_unsigned(ushort2, uint, uint);
+uint2 __ovld __cnfn bitfield_extract_unsigned(uint2, uint, uint);
+ulong2 __ovld __cnfn bitfield_extract_unsigned(ulong2, uint, uint);
+uchar3 __ovld __cnfn bitfield_extract_unsigned(uchar3, uint, uint);
+ushort3 __ovld __cnfn bitfield_extract_unsigned(ushort3, uint, uint);
+uint3 __ovld __cnfn bitfield_extract_unsigned(uint3, uint, uint);
+ulong3 __ovld __cnfn bitfield_extract_unsigned(ulong3, uint, uint);
+uchar4 __ovld __cnfn bitfield_extract_unsigned(uchar4, uint, uint);
+ushort4 __ovld __cnfn bitfield_extract_unsigned(ushort4, uint, uint);
+uint4 __ovld __cnfn bitfield_extract_unsigned(uint4, uint, uint);
+ulong4 __ovld __cnfn bitfield_extract_unsigned(ulong4, uint, uint);
+uchar8 __ovld __cnfn bitfield_extract_unsigned(uchar8, uint, uint);
+ushort8 __ovld __cnfn bitfield_extract_unsigned(ushort8, uint, uint);
+uint8 __ovld __cnfn bitfield_extract_unsigned(uint8, uint, uint);
+ulong8 __ovld __cnfn bitfield_extract_unsigned(ulong8, uint, uint);
+uchar16 __ovld __cnfn bitfield_extract_unsigned(uchar16, uint, uint);
+ushort16 __ovld __cnfn bitfield_extract_unsigned(ushort16, uint, uint);
+uint16 __ovld __cnfn bitfield_extract_unsigned(uint16, uint, uint);
+ulong16 __ovld __cnfn bitfield_extract_unsigned(ulong16, uint, uint);
+
+char __ovld __cnfn bit_reverse(char);
+uchar __ovld __cnfn bit_reverse(uchar);
+short __ovld __cnfn bit_reverse(short);
+ushort __ovld __cnfn bit_reverse(ushort);
+int __ovld __cnfn bit_reverse(int);
+uint __ovld __cnfn bit_reverse(uint);
+long __ovld __cnfn bit_reverse(long);
+ulong __ovld __cnfn bit_reverse(ulong);
+char2 __ovld __cnfn bit_reverse(char2);
+uchar2 __ovld __cnfn bit_reverse(uchar2);
+short2 __ovld __cnfn bit_reverse(short2);
+ushort2 __ovld __cnfn bit_reverse(ushort2);
+int2 __ovld __cnfn bit_reverse(int2);
+uint2 __ovld __cnfn bit_reverse(uint2);
+long2 __ovld __cnfn bit_reverse(long2);
+ulong2 __ovld __cnfn bit_reverse(ulong2);
+char3 __ovld __cnfn bit_reverse(char3);
+uchar3 __ovld __cnfn bit_reverse(uchar3);
+short3 __ovld __cnfn bit_reverse(short3);
+ushort3 __ovld __cnfn bit_reverse(ushort3);
+int3 __ovld __cnfn bit_reverse(int3);
+uint3 __ovld __cnfn bit_reverse(uint3);
+long3 __ovld __cnfn bit_reverse(long3);
+ulong3 __ovld __cnfn bit_reverse(ulong3);
+char4 __ovld __cnfn bit_reverse(char4);
+uchar4 __ovld __cnfn bit_reverse(uchar4);
+short4 __ovld __cnfn bit_reverse(short4);
+ushort4 __ovld __cnfn bit_reverse(ushort4);
+int4 __ovld __cnfn bit_reverse(int4);
+uint4 __ovld __cnfn bit_reverse(uint4);
+long4 __ovld __cnfn bit_reverse(long4);
+ulong4 __ovld __cnfn bit_reverse(ulong4);
+char8 __ovld __cnfn bit_reverse(char8);
+uchar8 __ovld __cnfn bit_reverse(uchar8);
+short8 __ovld __cnfn bit_reverse(short8);
+ushort8 __ovld __cnfn bit_reverse(ushort8);
+int8 __ovld __cnfn bit_reverse(int8);
+uint8 __ovld __cnfn bit_reverse(uint8);
+long8 __ovld __cnfn bit_reverse(long8);
+ulong8 __ovld __cnfn bit_reverse(ulong8);
+char16 __ovld __cnfn bit_reverse(char16);
+uchar16 __ovld __cnfn bit_reverse(uchar16);
+short16 __ovld __cnfn bit_reverse(short16);
+ushort16 __ovld __cnfn bit_reverse(ushort16);
+int16 __ovld __cnfn bit_reverse(int16);
+uint16 __ovld __cnfn bit_reverse(uint16);
+long16 __ovld __cnfn bit_reverse(long16);
+ulong16 __ovld __cnfn bit_reverse(ulong16);
+#endif // cl_khr_extended_bit_ops
+
+#if defined(__opencl_c_integer_dot_product_input_4x8bit)
+uint __ovld __cnfn dot(uchar4, uchar4);
+int __ovld __cnfn dot(char4, char4);
+int __ovld __cnfn dot(uchar4, char4);
+int __ovld __cnfn dot(char4, uchar4);
+
+uint __ovld __cnfn dot_acc_sat(uchar4, uchar4, uint);
+int __ovld __cnfn dot_acc_sat(char4, char4, int);
+int __ovld __cnfn dot_acc_sat(uchar4, char4, int);
+int __ovld __cnfn dot_acc_sat(char4, uchar4, int);
+#endif // __opencl_c_integer_dot_product_input_4x8bit
+
+#if defined(__opencl_c_integer_dot_product_input_4x8bit_packed)
+uint __ovld __cnfn dot_4x8packed_uu_uint(uint, uint);
+int __ovld __cnfn dot_4x8packed_ss_int(uint, uint);
+int __ovld __cnfn dot_4x8packed_us_int(uint, uint);
+int __ovld __cnfn dot_4x8packed_su_int(uint, uint);
+
+uint __ovld __cnfn dot_acc_sat_4x8packed_uu_uint(uint, uint, uint);
+int __ovld __cnfn dot_acc_sat_4x8packed_ss_int(uint, uint, int);
+int __ovld __cnfn dot_acc_sat_4x8packed_us_int(uint, uint, int);
+int __ovld __cnfn dot_acc_sat_4x8packed_su_int(uint, uint, int);
+#endif // __opencl_c_integer_dot_product_input_4x8bit_packed
+
+#if defined(cl_khr_subgroup_rotate)
+char __ovld __conv sub_group_rotate(char, int);
+uchar __ovld __conv sub_group_rotate(uchar, int);
+short __ovld __conv sub_group_rotate(short, int);
+ushort __ovld __conv sub_group_rotate(ushort, int);
+int __ovld __conv sub_group_rotate(int, int);
+uint __ovld __conv sub_group_rotate(uint, int);
+long __ovld __conv sub_group_rotate(long, int);
+ulong __ovld __conv sub_group_rotate(ulong, int);
+float __ovld __conv sub_group_rotate(float, int);
+#if defined(cl_khr_fp64)
+double __ovld __conv sub_group_rotate(double, int);
+#endif // cl_khr_fp64
+#if defined(cl_khr_fp16)
+half __ovld __conv sub_group_rotate(half, int);
+#endif // cl_khr_fp16
+
+char __ovld __conv sub_group_clustered_rotate(char, int, uint);
+uchar __ovld __conv sub_group_clustered_rotate(uchar, int, uint);
+short __ovld __conv sub_group_clustered_rotate(short, int, uint);
+ushort __ovld __conv sub_group_clustered_rotate(ushort, int, uint);
+int __ovld __conv sub_group_clustered_rotate(int, int, uint);
+uint __ovld __conv sub_group_clustered_rotate(uint, int, uint);
+long __ovld __conv sub_group_clustered_rotate(long, int, uint);
+ulong __ovld __conv sub_group_clustered_rotate(ulong, int, uint);
+float __ovld __conv sub_group_clustered_rotate(float, int, uint);
+#if defined(cl_khr_fp64)
+double __ovld __conv sub_group_clustered_rotate(double, int, uint);
+#endif // cl_khr_fp64
+#if defined(cl_khr_fp16)
+half __ovld __conv sub_group_clustered_rotate(half, int, uint);
+#endif // cl_khr_fp16
+#endif // cl_khr_subgroup_rotate
+
+#if defined(cl_intel_subgroups)
+// Intel-Specific Sub Group Functions
+float   __ovld __conv intel_sub_group_shuffle( float , uint );
+float2  __ovld __conv intel_sub_group_shuffle( float2, uint );
+float3  __ovld __conv intel_sub_group_shuffle( float3, uint );
+float4  __ovld __conv intel_sub_group_shuffle( float4, uint );
+float8  __ovld __conv intel_sub_group_shuffle( float8, uint );
+float16 __ovld __conv intel_sub_group_shuffle( float16, uint );
+
+int     __ovld __conv intel_sub_group_shuffle( int , uint );
+int2    __ovld __conv intel_sub_group_shuffle( int2, uint );
+int3    __ovld __conv intel_sub_group_shuffle( int3, uint );
+int4    __ovld __conv intel_sub_group_shuffle( int4, uint );
+int8    __ovld __conv intel_sub_group_shuffle( int8, uint );
+int16   __ovld __conv intel_sub_group_shuffle( int16, uint );
+
+uint    __ovld __conv intel_sub_group_shuffle( uint , uint );
+uint2   __ovld __conv intel_sub_group_shuffle( uint2, uint );
+uint3   __ovld __conv intel_sub_group_shuffle( uint3, uint );
+uint4   __ovld __conv intel_sub_group_shuffle( uint4, uint );
+uint8   __ovld __conv intel_sub_group_shuffle( uint8, uint );
+uint16  __ovld __conv intel_sub_group_shuffle( uint16, uint );
+
+long    __ovld __conv intel_sub_group_shuffle( long, uint );
+ulong   __ovld __conv intel_sub_group_shuffle( ulong, uint );
+
+float   __ovld __conv intel_sub_group_shuffle_down( float  cur, float  next, uint );
+float2  __ovld __conv intel_sub_group_shuffle_down( float2 cur, float2 next, uint );
+float3  __ovld __conv intel_sub_group_shuffle_down( float3 cur, float3 next, uint );
+float4  __ovld __conv intel_sub_group_shuffle_down( float4 cur, float4 next, uint );
+float8  __ovld __conv intel_sub_group_shuffle_down( float8 cur, float8 next, uint );
+float16 __ovld __conv intel_sub_group_shuffle_down( float16 cur, float16 next, uint );
+
+int     __ovld __conv intel_sub_group_shuffle_down( int  cur, int  next, uint );
+int2    __ovld __conv intel_sub_group_shuffle_down( int2 cur, int2 next, uint );
+int3    __ovld __conv intel_sub_group_shuffle_down( int3 cur, int3 next, uint );
+int4    __ovld __conv intel_sub_group_shuffle_down( int4 cur, int4 next, uint );
+int8    __ovld __conv intel_sub_group_shuffle_down( int8 cur, int8 next, uint );
+int16   __ovld __conv intel_sub_group_shuffle_down( int16 cur, int16 next, uint );
+
+uint    __ovld __conv intel_sub_group_shuffle_down( uint  cur, uint  next, uint );
+uint2   __ovld __conv intel_sub_group_shuffle_down( uint2 cur, uint2 next, uint );
+uint3   __ovld __conv intel_sub_group_shuffle_down( uint3 cur, uint3 next, uint );
+uint4   __ovld __conv intel_sub_group_shuffle_down( uint4 cur, uint4 next, uint );
+uint8   __ovld __conv intel_sub_group_shuffle_down( uint8 cur, uint8 next, uint );
+uint16  __ovld __conv intel_sub_group_shuffle_down( uint16 cur, uint16 next, uint );
+
+long    __ovld __conv intel_sub_group_shuffle_down( long prev, long cur, uint );
+ulong   __ovld __conv intel_sub_group_shuffle_down( ulong prev, ulong cur, uint );
+
+float   __ovld __conv intel_sub_group_shuffle_up( float  prev, float  cur, uint );
+float2  __ovld __conv intel_sub_group_shuffle_up( float2 prev, float2 cur, uint );
+float3  __ovld __conv intel_sub_group_shuffle_up( float3 prev, float3 cur, uint );
+float4  __ovld __conv intel_sub_group_shuffle_up( float4 prev, float4 cur, uint );
+float8  __ovld __conv intel_sub_group_shuffle_up( float8 prev, float8 cur, uint );
+float16 __ovld __conv intel_sub_group_shuffle_up( float16 prev, float16 cur, uint );
+
+int     __ovld __conv intel_sub_group_shuffle_up( int  prev, int  cur, uint );
+int2    __ovld __conv intel_sub_group_shuffle_up( int2 prev, int2 cur, uint );
+int3    __ovld __conv intel_sub_group_shuffle_up( int3 prev, int3 cur, uint );
+int4    __ovld __conv intel_sub_group_shuffle_up( int4 prev, int4 cur, uint );
+int8    __ovld __conv intel_sub_group_shuffle_up( int8 prev, int8 cur, uint );
+int16   __ovld __conv intel_sub_group_shuffle_up( int16 prev, int16 cur, uint );
+
+uint    __ovld __conv intel_sub_group_shuffle_up( uint  prev, uint  cur, uint );
+uint2   __ovld __conv intel_sub_group_shuffle_up( uint2 prev, uint2 cur, uint );
+uint3   __ovld __conv intel_sub_group_shuffle_up( uint3 prev, uint3 cur, uint );
+uint4   __ovld __conv intel_sub_group_shuffle_up( uint4 prev, uint4 cur, uint );
+uint8   __ovld __conv intel_sub_group_shuffle_up( uint8 prev, uint8 cur, uint );
+uint16  __ovld __conv intel_sub_group_shuffle_up( uint16 prev, uint16 cur, uint );
+
+long    __ovld __conv intel_sub_group_shuffle_up( long prev, long cur, uint );
+ulong   __ovld __conv intel_sub_group_shuffle_up( ulong prev, ulong cur, uint );
+
+float   __ovld __conv intel_sub_group_shuffle_xor( float , uint );
+float2  __ovld __conv intel_sub_group_shuffle_xor( float2, uint );
+float3  __ovld __conv intel_sub_group_shuffle_xor( float3, uint );
+float4  __ovld __conv intel_sub_group_shuffle_xor( float4, uint );
+float8  __ovld __conv intel_sub_group_shuffle_xor( float8, uint );
+float16 __ovld __conv intel_sub_group_shuffle_xor( float16, uint );
+
+int     __ovld __conv intel_sub_group_shuffle_xor( int , uint );
+int2    __ovld __conv intel_sub_group_shuffle_xor( int2, uint );
+int3    __ovld __conv intel_sub_group_shuffle_xor( int3, uint );
+int4    __ovld __conv intel_sub_group_shuffle_xor( int4, uint );
+int8    __ovld __conv intel_sub_group_shuffle_xor( int8, uint );
+int16   __ovld __conv intel_sub_group_shuffle_xor( int16, uint );
+
+uint    __ovld __conv intel_sub_group_shuffle_xor( uint , uint );
+uint2   __ovld __conv intel_sub_group_shuffle_xor( uint2, uint );
+uint3   __ovld __conv intel_sub_group_shuffle_xor( uint3, uint );
+uint4   __ovld __conv intel_sub_group_shuffle_xor( uint4, uint );
+uint8   __ovld __conv intel_sub_group_shuffle_xor( uint8, uint );
+uint16  __ovld __conv intel_sub_group_shuffle_xor( uint16, uint );
+
+long    __ovld __conv intel_sub_group_shuffle_xor( long, uint );
+ulong   __ovld __conv intel_sub_group_shuffle_xor( ulong, uint );
+
+#if defined(__opencl_c_images)
+uint    __ovld __conv intel_sub_group_block_read(read_only image2d_t, int2);
+uint2   __ovld __conv intel_sub_group_block_read2(read_only image2d_t, int2);
+uint4   __ovld __conv intel_sub_group_block_read4(read_only image2d_t, int2);
+uint8   __ovld __conv intel_sub_group_block_read8(read_only image2d_t, int2);
+
+#if defined(__opencl_c_read_write_images)
+uint    __ovld __conv intel_sub_group_block_read(read_write image2d_t, int2);
+uint2   __ovld __conv intel_sub_group_block_read2(read_write image2d_t, int2);
+uint4   __ovld __conv intel_sub_group_block_read4(read_write image2d_t, int2);
+uint8   __ovld __conv intel_sub_group_block_read8(read_write image2d_t, int2);
+#endif // defined(__opencl_c_read_write_images)
+#endif
+
+uint    __ovld __conv intel_sub_group_block_read( const __global uint* p );
+uint2   __ovld __conv intel_sub_group_block_read2( const __global uint* p );
+uint4   __ovld __conv intel_sub_group_block_read4( const __global uint* p );
+uint8   __ovld __conv intel_sub_group_block_read8( const __global uint* p );
+
+#if defined(__opencl_c_images)
+void    __ovld __conv intel_sub_group_block_write(write_only image2d_t, int2, uint);
+void    __ovld __conv intel_sub_group_block_write2(write_only image2d_t, int2, uint2);
+void    __ovld __conv intel_sub_group_block_write4(write_only image2d_t, int2, uint4);
+void    __ovld __conv intel_sub_group_block_write8(write_only image2d_t, int2, uint8);
+
+#if defined(__opencl_c_read_write_images)
+void    __ovld __conv intel_sub_group_block_write(read_write image2d_t, int2, uint);
+void    __ovld __conv intel_sub_group_block_write2(read_write image2d_t, int2, uint2);
+void    __ovld __conv intel_sub_group_block_write4(read_write image2d_t, int2, uint4);
+void    __ovld __conv intel_sub_group_block_write8(read_write image2d_t, int2, uint8);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+void    __ovld __conv intel_sub_group_block_write( __global uint* p, uint data );
+void    __ovld __conv intel_sub_group_block_write2( __global uint* p, uint2 data );
+void    __ovld __conv intel_sub_group_block_write4( __global uint* p, uint4 data );
+void    __ovld __conv intel_sub_group_block_write8( __global uint* p, uint8 data );
+
+#ifdef cl_khr_fp16
+half    __ovld __conv intel_sub_group_shuffle( half, uint );
+half    __ovld __conv intel_sub_group_shuffle_down( half prev, half cur, uint );
+half    __ovld __conv intel_sub_group_shuffle_up( half prev, half cur, uint );
+half    __ovld __conv intel_sub_group_shuffle_xor( half, uint );
+#endif
+
+#if defined(cl_khr_fp64)
+double  __ovld __conv intel_sub_group_shuffle( double, uint );
+double  __ovld __conv intel_sub_group_shuffle_down( double prev, double cur, uint );
+double  __ovld __conv intel_sub_group_shuffle_up( double prev, double cur, uint );
+double  __ovld __conv intel_sub_group_shuffle_xor( double, uint );
+#endif
+
+#endif //cl_intel_subgroups
+
+#if defined(cl_intel_subgroups_short)
+short       __ovld __conv intel_sub_group_broadcast( short , uint sub_group_local_id );
+short2      __ovld __conv intel_sub_group_broadcast( short2, uint sub_group_local_id );
+short3      __ovld __conv intel_sub_group_broadcast( short3, uint sub_group_local_id );
+short4      __ovld __conv intel_sub_group_broadcast( short4, uint sub_group_local_id );
+short8      __ovld __conv intel_sub_group_broadcast( short8, uint sub_group_local_id );
+
+ushort      __ovld __conv intel_sub_group_broadcast( ushort , uint sub_group_local_id );
+ushort2     __ovld __conv intel_sub_group_broadcast( ushort2, uint sub_group_local_id );
+ushort3     __ovld __conv intel_sub_group_broadcast( ushort3, uint sub_group_local_id );
+ushort4     __ovld __conv intel_sub_group_broadcast( ushort4, uint sub_group_local_id );
+ushort8     __ovld __conv intel_sub_group_broadcast( ushort8, uint sub_group_local_id );
+
+short       __ovld __conv intel_sub_group_shuffle( short  , uint );
+short2      __ovld __conv intel_sub_group_shuffle( short2 , uint );
+short3      __ovld __conv intel_sub_group_shuffle( short3 , uint );
+short4      __ovld __conv intel_sub_group_shuffle( short4 , uint );
+short8      __ovld __conv intel_sub_group_shuffle( short8 , uint );
+short16     __ovld __conv intel_sub_group_shuffle( short16, uint);
+
+ushort      __ovld __conv intel_sub_group_shuffle( ushort  , uint );
+ushort2     __ovld __conv intel_sub_group_shuffle( ushort2 , uint );
+ushort3     __ovld __conv intel_sub_group_shuffle( ushort3 , uint );
+ushort4     __ovld __conv intel_sub_group_shuffle( ushort4 , uint );
+ushort8     __ovld __conv intel_sub_group_shuffle( ushort8 , uint );
+ushort16    __ovld __conv intel_sub_group_shuffle( ushort16, uint );
+
+short       __ovld __conv intel_sub_group_shuffle_down( short   cur, short   next, uint );
+short2      __ovld __conv intel_sub_group_shuffle_down( short2  cur, short2  next, uint );
+short3      __ovld __conv intel_sub_group_shuffle_down( short3  cur, short3  next, uint );
+short4      __ovld __conv intel_sub_group_shuffle_down( short4  cur, short4  next, uint );
+short8      __ovld __conv intel_sub_group_shuffle_down( short8  cur, short8  next, uint );
+short16     __ovld __conv intel_sub_group_shuffle_down( short16 cur, short16 next, uint );
+
+ushort      __ovld __conv intel_sub_group_shuffle_down( ushort   cur, ushort   next, uint );
+ushort2     __ovld __conv intel_sub_group_shuffle_down( ushort2  cur, ushort2  next, uint );
+ushort3     __ovld __conv intel_sub_group_shuffle_down( ushort3  cur, ushort3  next, uint );
+ushort4     __ovld __conv intel_sub_group_shuffle_down( ushort4  cur, ushort4  next, uint );
+ushort8     __ovld __conv intel_sub_group_shuffle_down( ushort8  cur, ushort8  next, uint );
+ushort16    __ovld __conv intel_sub_group_shuffle_down( ushort16 cur, ushort16 next, uint );
+
+short       __ovld __conv intel_sub_group_shuffle_up( short   cur, short   next, uint );
+short2      __ovld __conv intel_sub_group_shuffle_up( short2  cur, short2  next, uint );
+short3      __ovld __conv intel_sub_group_shuffle_up( short3  cur, short3  next, uint );
+short4      __ovld __conv intel_sub_group_shuffle_up( short4  cur, short4  next, uint );
+short8      __ovld __conv intel_sub_group_shuffle_up( short8  cur, short8  next, uint );
+short16     __ovld __conv intel_sub_group_shuffle_up( short16 cur, short16 next, uint );
+
+ushort      __ovld __conv intel_sub_group_shuffle_up( ushort   cur, ushort   next, uint );
+ushort2     __ovld __conv intel_sub_group_shuffle_up( ushort2  cur, ushort2  next, uint );
+ushort3     __ovld __conv intel_sub_group_shuffle_up( ushort3  cur, ushort3  next, uint );
+ushort4     __ovld __conv intel_sub_group_shuffle_up( ushort4  cur, ushort4  next, uint );
+ushort8     __ovld __conv intel_sub_group_shuffle_up( ushort8  cur, ushort8  next, uint );
+ushort16    __ovld __conv intel_sub_group_shuffle_up( ushort16 cur, ushort16 next, uint );
+
+short       __ovld __conv intel_sub_group_shuffle_xor( short  , uint );
+short2      __ovld __conv intel_sub_group_shuffle_xor( short2 , uint );
+short3      __ovld __conv intel_sub_group_shuffle_xor( short3 , uint );
+short4      __ovld __conv intel_sub_group_shuffle_xor( short4 , uint );
+short8      __ovld __conv intel_sub_group_shuffle_xor( short8 , uint );
+short16     __ovld __conv intel_sub_group_shuffle_xor( short16, uint );
+
+ushort      __ovld __conv intel_sub_group_shuffle_xor( ushort  , uint );
+ushort2     __ovld __conv intel_sub_group_shuffle_xor( ushort2 , uint );
+ushort3     __ovld __conv intel_sub_group_shuffle_xor( ushort3 , uint );
+ushort4     __ovld __conv intel_sub_group_shuffle_xor( ushort4 , uint );
+ushort8     __ovld __conv intel_sub_group_shuffle_xor( ushort8 , uint );
+ushort16    __ovld __conv intel_sub_group_shuffle_xor( ushort16, uint );
+
+short       __ovld __conv intel_sub_group_reduce_add( short   x );
+ushort      __ovld __conv intel_sub_group_reduce_add( ushort  x );
+short       __ovld __conv intel_sub_group_reduce_min( short   x );
+ushort      __ovld __conv intel_sub_group_reduce_min( ushort  x );
+short       __ovld __conv intel_sub_group_reduce_max( short   x );
+ushort      __ovld __conv intel_sub_group_reduce_max( ushort  x );
+
+short       __ovld __conv intel_sub_group_scan_exclusive_add( short   x );
+ushort      __ovld __conv intel_sub_group_scan_exclusive_add( ushort  x );
+short       __ovld __conv intel_sub_group_scan_exclusive_min( short   x );
+ushort      __ovld __conv intel_sub_group_scan_exclusive_min( ushort  x );
+short       __ovld __conv intel_sub_group_scan_exclusive_max( short   x );
+ushort      __ovld __conv intel_sub_group_scan_exclusive_max( ushort  x );
+
+short       __ovld __conv intel_sub_group_scan_inclusive_add( short   x );
+ushort      __ovld __conv intel_sub_group_scan_inclusive_add( ushort  x );
+short       __ovld __conv intel_sub_group_scan_inclusive_min( short   x );
+ushort      __ovld __conv intel_sub_group_scan_inclusive_min( ushort  x );
+short       __ovld __conv intel_sub_group_scan_inclusive_max( short   x );
+ushort      __ovld __conv intel_sub_group_scan_inclusive_max( ushort  x );
+
+#if defined(__opencl_c_images)
+uint       __ovld __conv intel_sub_group_block_read_ui(read_only image2d_t, int2);
+uint2      __ovld __conv intel_sub_group_block_read_ui2(read_only image2d_t, int2);
+uint4      __ovld __conv intel_sub_group_block_read_ui4(read_only image2d_t, int2);
+uint8      __ovld __conv intel_sub_group_block_read_ui8(read_only image2d_t, int2);
+
+#if defined(__opencl_c_read_write_images)
+uint       __ovld __conv intel_sub_group_block_read_ui(read_write image2d_t, int2);
+uint2      __ovld __conv intel_sub_group_block_read_ui2(read_write image2d_t, int2);
+uint4      __ovld __conv intel_sub_group_block_read_ui4(read_write image2d_t, int2);
+uint8      __ovld __conv intel_sub_group_block_read_ui8(read_write image2d_t, int2);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+uint       __ovld __conv intel_sub_group_block_read_ui( const __global uint* p );
+uint2      __ovld __conv intel_sub_group_block_read_ui2( const __global uint* p );
+uint4      __ovld __conv intel_sub_group_block_read_ui4( const __global uint* p );
+uint8      __ovld __conv intel_sub_group_block_read_ui8( const __global uint* p );
+
+#if defined(__opencl_c_images)
+void       __ovld __conv intel_sub_group_block_write_ui(read_only image2d_t, int2, uint);
+void       __ovld __conv intel_sub_group_block_write_ui2(read_only image2d_t, int2, uint2);
+void       __ovld __conv intel_sub_group_block_write_ui4(read_only image2d_t, int2, uint4);
+void       __ovld __conv intel_sub_group_block_write_ui8(read_only image2d_t, int2, uint8);
+
+#if defined(__opencl_c_read_write_images)
+void       __ovld __conv intel_sub_group_block_write_ui(read_write image2d_t, int2, uint);
+void       __ovld __conv intel_sub_group_block_write_ui2(read_write image2d_t, int2, uint2);
+void       __ovld __conv intel_sub_group_block_write_ui4(read_write image2d_t, int2, uint4);
+void       __ovld __conv intel_sub_group_block_write_ui8(read_write image2d_t, int2, uint8);
+#endif // defined(__opencl_c_read_write_images)
+#endif //defined(__opencl_c_images)
+
+void       __ovld __conv intel_sub_group_block_write_ui( __global uint* p, uint data );
+void       __ovld __conv intel_sub_group_block_write_ui2( __global uint* p, uint2 data );
+void       __ovld __conv intel_sub_group_block_write_ui4( __global uint* p, uint4 data );
+void       __ovld __conv intel_sub_group_block_write_ui8( __global uint* p, uint8 data );
+
+#if defined(__opencl_c_images)
+ushort      __ovld __conv intel_sub_group_block_read_us(read_only image2d_t, int2);
+ushort2     __ovld __conv intel_sub_group_block_read_us2(read_only image2d_t, int2);
+ushort4     __ovld __conv intel_sub_group_block_read_us4(read_only image2d_t, int2);
+ushort8     __ovld __conv intel_sub_group_block_read_us8(read_only image2d_t, int2);
+
+#if defined(__opencl_c_read_write_images)
+ushort      __ovld __conv intel_sub_group_block_read_us(read_write image2d_t, int2);
+ushort2     __ovld __conv intel_sub_group_block_read_us2(read_write image2d_t, int2);
+ushort4     __ovld __conv intel_sub_group_block_read_us4(read_write image2d_t, int2);
+ushort8     __ovld __conv intel_sub_group_block_read_us8(read_write image2d_t, int2);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+ushort      __ovld __conv intel_sub_group_block_read_us(  const __global ushort* p );
+ushort2     __ovld __conv intel_sub_group_block_read_us2( const __global ushort* p );
+ushort4     __ovld __conv intel_sub_group_block_read_us4( const __global ushort* p );
+ushort8     __ovld __conv intel_sub_group_block_read_us8( const __global ushort* p );
+
+#if defined(__opencl_c_images)
+void        __ovld __conv intel_sub_group_block_write_us(write_only image2d_t, int2, ushort);
+void        __ovld __conv intel_sub_group_block_write_us2(write_only image2d_t, int2, ushort2);
+void        __ovld __conv intel_sub_group_block_write_us4(write_only image2d_t, int2, ushort4);
+void        __ovld __conv intel_sub_group_block_write_us8(write_only image2d_t, int2, ushort8);
+
+#if defined(__opencl_c_read_write_images)
+void        __ovld __conv intel_sub_group_block_write_us(read_write image2d_t, int2, ushort);
+void        __ovld __conv intel_sub_group_block_write_us2(read_write image2d_t, int2, ushort2);
+void        __ovld __conv intel_sub_group_block_write_us4(read_write image2d_t, int2, ushort4);
+void        __ovld __conv intel_sub_group_block_write_us8(read_write image2d_t, int2, ushort8);
+#endif // defined(__opencl_c_read_write_images)
+#endif // defined(__opencl_c_images)
+
+void        __ovld __conv intel_sub_group_block_write_us(  __global ushort* p, ushort  data );
+void        __ovld __conv intel_sub_group_block_write_us2( __global ushort* p, ushort2 data );
+void        __ovld __conv intel_sub_group_block_write_us4( __global ushort* p, ushort4 data );
+void        __ovld __conv intel_sub_group_block_write_us8( __global ushort* p, ushort8 data );
+#endif // cl_intel_subgroups_short
+
+#ifdef cl_intel_device_side_avc_motion_estimation
+#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : begin
+
+// MCE built-in functions
+uchar __ovld
+intel_sub_group_avc_mce_get_default_inter_base_multi_reference_penalty(
+    uchar slice_type, uchar qp);
+ulong __ovld intel_sub_group_avc_mce_get_default_inter_shape_penalty(
+    uchar slice_type, uchar qp);
+uchar __ovld intel_sub_group_avc_mce_get_default_inter_direction_penalty(
+    uchar slice_type, uchar qp);
+uint __ovld intel_sub_group_avc_mce_get_default_intra_luma_shape_penalty(
+    uchar slice_type, uchar qp);
+uint2 __ovld
+intel_sub_group_avc_mce_get_default_inter_motion_vector_cost_table(
+    uchar slice_type, uchar qp);
+uchar __ovld intel_sub_group_avc_mce_get_default_intra_luma_mode_penalty(
+    uchar slice_type, uchar qp);
+
+uint2 __ovld intel_sub_group_avc_mce_get_default_high_penalty_cost_table();
+uint2 __ovld intel_sub_group_avc_mce_get_default_medium_penalty_cost_table();
+uint2 __ovld intel_sub_group_avc_mce_get_default_low_penalty_cost_table();
+uint __ovld intel_sub_group_avc_mce_get_default_non_dc_luma_intra_penalty();
+uchar __ovld
+intel_sub_group_avc_mce_get_default_intra_chroma_mode_base_penalty();
+
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_inter_base_multi_reference_penalty(
+    uchar reference_base_penalty, intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_inter_shape_penalty(
+    ulong packed_shape_penalty, intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_inter_direction_penalty(
+    uchar direction_cost, intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_motion_vector_cost_function(
+    ulong packed_cost_center_delta, uint2 packed_cost_table,
+    uchar cost_precision, intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_ac_only_haar(
+    intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_source_interlaced_field_polarity(
+    uchar src_field_polarity, intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_single_reference_interlaced_field_polarity(
+    uchar ref_field_polarity, intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_mce_set_dual_reference_interlaced_field_polarities(
+    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
+    intel_sub_group_avc_mce_payload_t payload);
+
+ulong __ovld intel_sub_group_avc_mce_get_motion_vectors(
+    intel_sub_group_avc_mce_result_t result);
+ushort __ovld intel_sub_group_avc_mce_get_inter_distortions(
+    intel_sub_group_avc_mce_result_t result);
+ushort __ovld intel_sub_group_avc_mce_get_best_inter_distortion(
+    intel_sub_group_avc_mce_result_t result);
+uchar __ovld intel_sub_group_avc_mce_get_inter_major_shape(
+    intel_sub_group_avc_mce_result_t result);
+uchar __ovld intel_sub_group_avc_mce_get_inter_minor_shapes(
+    intel_sub_group_avc_mce_result_t result);
+uchar __ovld intel_sub_group_avc_mce_get_inter_directions(
+    intel_sub_group_avc_mce_result_t result);
+uchar __ovld intel_sub_group_avc_mce_get_inter_motion_vector_count(
+    intel_sub_group_avc_mce_result_t result);
+uint __ovld intel_sub_group_avc_mce_get_inter_reference_ids(
+    intel_sub_group_avc_mce_result_t result);
+uchar __ovld
+intel_sub_group_avc_mce_get_inter_reference_interlaced_field_polarities(
+    uint packed_reference_ids, uint packed_reference_parameter_field_polarities,
+    intel_sub_group_avc_mce_result_t result);
+
+// IME built-in functions
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_initialize(
+    ushort2 src_coord, uchar partition_mask, uchar sad_adjustment);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_single_reference(
+    short2 ref_offset, uchar search_window_config,
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_dual_reference(
+    short2 fwd_ref_offset, short2 bwd_ref_offset, uchar search_window_config,
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_max_motion_vector_count(
+    uchar max_motion_vector_count, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_unidirectional_mix_disable(
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_early_search_termination_threshold(
+    uchar threshold, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_weighted_sad(
+    uint packed_sad_weights, intel_sub_group_avc_ime_payload_t payload);
+
+__attribute__((deprecated("If you use the latest Intel driver, please use "
+                          "intel_sub_group_avc_ime_ref_window_size instead",
+                          "intel_sub_group_avc_ime_ref_window_size")))
+ushort2 __ovld
+intel_sub_group_ime_ref_window_size(uchar search_window_config, char dual_ref);
+ushort2 __ovld intel_sub_group_avc_ime_ref_window_size(
+    uchar search_window_config, char dual_ref);
+short2 __ovld intel_sub_group_avc_ime_adjust_ref_offset(
+    short2 ref_offset, ushort2 src_coord, ushort2 ref_window_size,
+    ushort2 image_size);
+
+#if defined(__opencl_c_images)
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_ime_evaluate_with_single_reference(
+    read_only image2d_t src_image, read_only image2d_t ref_image,
+    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_ime_evaluate_with_dual_reference(
+    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
+    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld
+intel_sub_group_avc_ime_evaluate_with_single_reference_streamout(
+    read_only image2d_t src_image, read_only image2d_t ref_image,
+    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld
+intel_sub_group_avc_ime_evaluate_with_dual_reference_streamout(
+    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
+    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_ime_evaluate_with_single_reference_streamin(
+    read_only image2d_t src_image, read_only image2d_t ref_image,
+    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload,
+    intel_sub_group_avc_ime_single_reference_streamin_t streamin_components);
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_ime_evaluate_with_dual_reference_streamin(
+    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
+    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_ime_payload_t payload,
+    intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);
+intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld
+intel_sub_group_avc_ime_evaluate_with_single_reference_streaminout(
+    read_only image2d_t src_image, read_only image2d_t ref_image,
+    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload,
+    intel_sub_group_avc_ime_single_reference_streamin_t streamin_components);
+intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld
+intel_sub_group_avc_ime_evaluate_with_dual_reference_streaminout(
+    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
+    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_ime_payload_t payload,
+    intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);
+#endif
+
+intel_sub_group_avc_ime_single_reference_streamin_t __ovld
+intel_sub_group_avc_ime_get_single_reference_streamin(
+    intel_sub_group_avc_ime_result_single_reference_streamout_t result);
+intel_sub_group_avc_ime_dual_reference_streamin_t __ovld
+intel_sub_group_avc_ime_get_dual_reference_streamin(
+    intel_sub_group_avc_ime_result_dual_reference_streamout_t result);
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_ime_strip_single_reference_streamout(
+    intel_sub_group_avc_ime_result_single_reference_streamout_t result);
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_ime_strip_dual_reference_streamout(
+    intel_sub_group_avc_ime_result_dual_reference_streamout_t result);
+
+uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors(
+    intel_sub_group_avc_ime_result_single_reference_streamout_t result,
+    uchar major_shape);
+ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions(
+    intel_sub_group_avc_ime_result_single_reference_streamout_t result,
+    uchar major_shape);
+uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids(
+    intel_sub_group_avc_ime_result_single_reference_streamout_t result,
+    uchar major_shape);
+uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors(
+    intel_sub_group_avc_ime_result_dual_reference_streamout_t result,
+    uchar major_shape, uchar direction);
+ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions(
+    intel_sub_group_avc_ime_result_dual_reference_streamout_t result,
+    uchar major_shape, uchar direction);
+uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids(
+    intel_sub_group_avc_ime_result_dual_reference_streamout_t result,
+    uchar major_shape, uchar direction);
+
+uchar __ovld intel_sub_group_avc_ime_get_border_reached(
+    uchar image_select, intel_sub_group_avc_ime_result_t result);
+uchar __ovld intel_sub_group_avc_ime_get_truncated_search_indication(
+    intel_sub_group_avc_ime_result_t result);
+uchar __ovld
+intel_sub_group_avc_ime_get_unidirectional_early_search_termination(
+    intel_sub_group_avc_ime_result_t result);
+uint __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_motion_vector(
+    intel_sub_group_avc_ime_result_t result);
+ushort __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_distortion(
+    intel_sub_group_avc_ime_result_t result);
+
+// REF built-in functions
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_fme_initialize(
+    ushort2 src_coord, ulong motion_vectors, uchar major_shapes,
+    uchar minor_shapes, uchar directions, uchar pixel_resolution,
+    uchar sad_adjustment);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_bme_initialize(
+    ushort2 src_coord, ulong motion_vectors, uchar major_shapes,
+    uchar minor_shapes, uchar directions, uchar pixel_resolution,
+    uchar bidirectional_weight, uchar sad_adjustment);
+
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_bidirectional_mix_disable(
+    intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_bilinear_filter_enable(
+    intel_sub_group_avc_ref_payload_t payload);
+
+#if defined(__opencl_c_images)
+intel_sub_group_avc_ref_result_t __ovld
+intel_sub_group_avc_ref_evaluate_with_single_reference(
+    read_only image2d_t src_image, read_only image2d_t ref_image,
+    sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_ref_result_t __ovld
+intel_sub_group_avc_ref_evaluate_with_dual_reference(
+    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
+    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_ref_result_t __ovld
+intel_sub_group_avc_ref_evaluate_with_multi_reference(
+    read_only image2d_t src_image, uint packed_reference_ids,
+    sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_ref_result_t __ovld
+intel_sub_group_avc_ref_evaluate_with_multi_reference(
+    read_only image2d_t src_image, uint packed_reference_ids,
+    uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
+    intel_sub_group_avc_ref_payload_t payload);
+#endif //defined(__opencl_c_images)
+
+// SIC built-in functions
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_initialize(
+    ushort2 src_coord);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_configure_skc(
+    uint skip_block_partition_type, uint skip_motion_vector_mask,
+    ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment,
+    intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe(
+    uchar luma_intra_partition_mask, uchar intra_neighbour_availability,
+    uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
+    uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
+    uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe(
+    uchar luma_intra_partition_mask, uchar intra_neighbour_availability,
+    uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
+    uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
+    ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel,
+    ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment,
+    intel_sub_group_avc_sic_payload_t payload);
+uint __ovld
+intel_sub_group_avc_sic_get_motion_vector_mask(
+    uint skip_block_partition_type, uchar direction);
+
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_intra_luma_shape_penalty(
+    uint packed_shape_cost, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_intra_luma_mode_cost_function(
+    uchar luma_mode_penalty, uint luma_packed_neighbor_modes,
+    uint luma_packed_non_dc_penalty, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_intra_chroma_mode_cost_function(
+    uchar chroma_mode_penalty, intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_skc_bilinear_filter_enable(
+    intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_skc_forward_transform_enable(
+    ulong packed_sad_coefficients, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_block_based_raw_skip_sad(
+    uchar block_based_skip_type,
+    intel_sub_group_avc_sic_payload_t payload);
+
+#if defined(__opencl_c_images)
+intel_sub_group_avc_sic_result_t __ovld
+intel_sub_group_avc_sic_evaluate_ipe(
+    read_only image2d_t src_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_result_t __ovld
+intel_sub_group_avc_sic_evaluate_with_single_reference(
+    read_only image2d_t src_image, read_only image2d_t ref_image,
+    sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_result_t __ovld
+intel_sub_group_avc_sic_evaluate_with_dual_reference(
+    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
+    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
+    intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_result_t __ovld
+intel_sub_group_avc_sic_evaluate_with_multi_reference(
+    read_only image2d_t src_image, uint packed_reference_ids,
+    sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_result_t __ovld
+intel_sub_group_avc_sic_evaluate_with_multi_reference(
+    read_only image2d_t src_image, uint packed_reference_ids,
+    uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
+    intel_sub_group_avc_sic_payload_t payload);
+#endif //defined(__opencl_c_images)
+
+uchar __ovld intel_sub_group_avc_sic_get_ipe_luma_shape(
+    intel_sub_group_avc_sic_result_t result);
+ushort __ovld intel_sub_group_avc_sic_get_best_ipe_luma_distortion(
+    intel_sub_group_avc_sic_result_t result);
+ushort __ovld intel_sub_group_avc_sic_get_best_ipe_chroma_distortion(
+    intel_sub_group_avc_sic_result_t result);
+ulong __ovld intel_sub_group_avc_sic_get_packed_ipe_luma_modes(
+    intel_sub_group_avc_sic_result_t result);
+uchar __ovld intel_sub_group_avc_sic_get_ipe_chroma_mode(
+    intel_sub_group_avc_sic_result_t result);
+uint __ovld intel_sub_group_avc_sic_get_packed_skc_luma_count_threshold(
+    intel_sub_group_avc_sic_result_t result);
+ulong __ovld intel_sub_group_avc_sic_get_packed_skc_luma_sum_threshold(
+    intel_sub_group_avc_sic_result_t result);
+ushort __ovld intel_sub_group_avc_sic_get_inter_raw_sads(
+    intel_sub_group_avc_sic_result_t result);
+
+// Wrappers
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_inter_base_multi_reference_penalty(
+    uchar reference_base_penalty, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_inter_base_multi_reference_penalty(
+    uchar reference_base_penalty, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_inter_base_multi_reference_penalty(
+    uchar reference_base_penalty, intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_inter_shape_penalty(
+    ulong packed_shape_cost, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_inter_shape_penalty(
+    ulong packed_shape_cost, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_inter_shape_penalty(
+    ulong packed_shape_cost, intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_inter_direction_penalty(
+    uchar direction_cost, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_inter_direction_penalty(
+    uchar direction_cost, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_inter_direction_penalty(
+    uchar direction_cost, intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_motion_vector_cost_function(
+    ulong packed_cost_center_delta, uint2 packed_cost_table,
+    uchar cost_precision, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_motion_vector_cost_function(
+    ulong packed_cost_center_delta, uint2 packed_cost_table,
+    uchar cost_precision, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_motion_vector_cost_function(
+    ulong packed_cost_center_delta, uint2 packed_cost_table,
+    uchar cost_precision, intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_source_interlaced_field_polarity(
+    uchar src_field_polarity, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_source_interlaced_field_polarity(
+    uchar src_field_polarity, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_source_interlaced_field_polarity(
+    uchar src_field_polarity, intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_single_reference_interlaced_field_polarity(
+    uchar ref_field_polarity, intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_single_reference_interlaced_field_polarity(
+    uchar ref_field_polarity, intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_single_reference_interlaced_field_polarity(
+    uchar ref_field_polarity, intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_dual_reference_interlaced_field_polarities(
+    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_dual_reference_interlaced_field_polarities(
+    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
+    intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_dual_reference_interlaced_field_polarities(
+    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
+    intel_sub_group_avc_sic_payload_t payload);
+
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_ime_set_ac_only_haar(
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_ref_set_ac_only_haar(
+    intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_sic_set_ac_only_haar(
+    intel_sub_group_avc_sic_payload_t payload);
+
+ulong __ovld intel_sub_group_avc_ime_get_motion_vectors(
+    intel_sub_group_avc_ime_result_t result);
+ulong __ovld intel_sub_group_avc_ref_get_motion_vectors(
+    intel_sub_group_avc_ref_result_t result);
+
+ushort __ovld intel_sub_group_avc_ime_get_inter_distortions(
+    intel_sub_group_avc_ime_result_t result);
+ushort __ovld intel_sub_group_avc_ref_get_inter_distortions(
+    intel_sub_group_avc_ref_result_t result);
+ushort __ovld intel_sub_group_avc_sic_get_inter_distortions(
+    intel_sub_group_avc_sic_result_t result);
+
+ushort __ovld intel_sub_group_avc_ime_get_best_inter_distortion(
+    intel_sub_group_avc_ime_result_t result);
+ushort __ovld intel_sub_group_avc_ref_get_best_inter_distortion(
+    intel_sub_group_avc_ref_result_t result);
+
+uchar __ovld intel_sub_group_avc_ime_get_inter_major_shape(
+    intel_sub_group_avc_ime_result_t result);
+uchar __ovld intel_sub_group_avc_ref_get_inter_major_shape(
+    intel_sub_group_avc_ref_result_t result);
+uchar __ovld intel_sub_group_avc_ime_get_inter_minor_shapes(
+    intel_sub_group_avc_ime_result_t result);
+uchar __ovld intel_sub_group_avc_ref_get_inter_minor_shapes(
+    intel_sub_group_avc_ref_result_t result);
+
+uchar __ovld intel_sub_group_avc_ime_get_inter_directions(
+    intel_sub_group_avc_ime_result_t result);
+uchar __ovld intel_sub_group_avc_ref_get_inter_directions(
+    intel_sub_group_avc_ref_result_t result);
+
+uchar __ovld intel_sub_group_avc_ime_get_inter_motion_vector_count(
+    intel_sub_group_avc_ime_result_t result);
+uchar __ovld intel_sub_group_avc_ref_get_inter_motion_vector_count(
+    intel_sub_group_avc_ref_result_t result);
+
+uint __ovld intel_sub_group_avc_ime_get_inter_reference_ids(
+    intel_sub_group_avc_ime_result_t result);
+uint __ovld intel_sub_group_avc_ref_get_inter_reference_ids(
+    intel_sub_group_avc_ref_result_t result);
+
+uchar __ovld
+intel_sub_group_avc_ime_get_inter_reference_interlaced_field_polarities(
+    uint packed_reference_ids, uint packed_reference_parameter_field_polarities,
+    intel_sub_group_avc_ime_result_t result);
+uchar __ovld
+intel_sub_group_avc_ref_get_inter_reference_interlaced_field_polarities(
+    uint packed_reference_ids, uint packed_reference_parameter_field_polarities,
+    intel_sub_group_avc_ref_result_t result);
+
+// Type conversion functions
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_ime_convert_to_mce_payload(
+    intel_sub_group_avc_ime_payload_t payload);
+intel_sub_group_avc_ime_payload_t __ovld
+intel_sub_group_avc_mce_convert_to_ime_payload(
+    intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_ref_convert_to_mce_payload(
+    intel_sub_group_avc_ref_payload_t payload);
+intel_sub_group_avc_ref_payload_t __ovld
+intel_sub_group_avc_mce_convert_to_ref_payload(
+    intel_sub_group_avc_mce_payload_t payload);
+intel_sub_group_avc_mce_payload_t __ovld
+intel_sub_group_avc_sic_convert_to_mce_payload(
+    intel_sub_group_avc_sic_payload_t payload);
+intel_sub_group_avc_sic_payload_t __ovld
+intel_sub_group_avc_mce_convert_to_sic_payload(
+    intel_sub_group_avc_mce_payload_t payload);
+
+intel_sub_group_avc_mce_result_t __ovld
+intel_sub_group_avc_ime_convert_to_mce_result(
+    intel_sub_group_avc_ime_result_t result);
+intel_sub_group_avc_ime_result_t __ovld
+intel_sub_group_avc_mce_convert_to_ime_result(
+    intel_sub_group_avc_mce_result_t result);
+intel_sub_group_avc_mce_result_t __ovld
+intel_sub_group_avc_ref_convert_to_mce_result(
+    intel_sub_group_avc_ref_result_t result);
+intel_sub_group_avc_ref_result_t __ovld
+intel_sub_group_avc_mce_convert_to_ref_result(
+    intel_sub_group_avc_mce_result_t result);
+intel_sub_group_avc_mce_result_t __ovld
+intel_sub_group_avc_sic_convert_to_mce_result(
+    intel_sub_group_avc_sic_result_t result);
+intel_sub_group_avc_sic_result_t __ovld
+intel_sub_group_avc_mce_convert_to_sic_result(
+    intel_sub_group_avc_mce_result_t result);
+#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : end
+#endif // cl_intel_device_side_avc_motion_estimation
+
+#ifdef cl_amd_media_ops
+uint __ovld amd_bitalign(uint, uint, uint);
+uint2 __ovld amd_bitalign(uint2, uint2, uint2);
+uint3 __ovld amd_bitalign(uint3, uint3, uint3);
+uint4 __ovld amd_bitalign(uint4, uint4, uint4);
+uint8 __ovld amd_bitalign(uint8, uint8, uint8);
+uint16 __ovld amd_bitalign(uint16, uint16, uint16);
+
+uint __ovld amd_bytealign(uint, uint, uint);
+uint2 __ovld amd_bytealign(uint2, uint2, uint2);
+uint3 __ovld amd_bytealign(uint3, uint3, uint3);
+uint4 __ovld amd_bytealign(uint4, uint4, uint4);
+uint8 __ovld amd_bytealign(uint8, uint8, uint8);
+uint16 __ovld amd_bytealign(uint16, uint16, uint16);
+
+uint __ovld amd_lerp(uint, uint, uint);
+uint2 __ovld amd_lerp(uint2, uint2, uint2);
+uint3 __ovld amd_lerp(uint3, uint3, uint3);
+uint4 __ovld amd_lerp(uint4, uint4, uint4);
+uint8 __ovld amd_lerp(uint8, uint8, uint8);
+uint16 __ovld amd_lerp(uint16, uint16, uint16);
+
+uint __ovld amd_pack(float4 v);
+
+uint __ovld amd_sad4(uint4, uint4, uint);
+
+uint __ovld amd_sadhi(uint, uint, uint);
+uint2 __ovld amd_sadhi(uint2, uint2, uint2);
+uint3 __ovld amd_sadhi(uint3, uint3, uint3);
+uint4 __ovld amd_sadhi(uint4, uint4, uint4);
+uint8 __ovld amd_sadhi(uint8, uint8, uint8);
+uint16 __ovld amd_sadhi(uint16, uint16, uint16);
+
+uint __ovld amd_sad(uint, uint, uint);
+uint2 __ovld amd_sad(uint2, uint2, uint2);
+uint3 __ovld amd_sad(uint3, uint3, uint3);
+uint4 __ovld amd_sad(uint4, uint4, uint4);
+uint8 __ovld amd_sad(uint8, uint8, uint8);
+uint16 __ovld amd_sad(uint16, uint16, uint16);
+
+float __ovld amd_unpack0(uint);
+float2 __ovld amd_unpack0(uint2);
+float3 __ovld amd_unpack0(uint3);
+float4 __ovld amd_unpack0(uint4);
+float8 __ovld amd_unpack0(uint8);
+float16 __ovld amd_unpack0(uint16);
+
+float __ovld amd_unpack1(uint);
+float2 __ovld amd_unpack1(uint2);
+float3 __ovld amd_unpack1(uint3);
+float4 __ovld amd_unpack1(uint4);
+float8 __ovld amd_unpack1(uint8);
+float16 __ovld amd_unpack1(uint16);
+
+float __ovld amd_unpack2(uint);
+float2 __ovld amd_unpack2(uint2);
+float3 __ovld amd_unpack2(uint3);
+float4 __ovld amd_unpack2(uint4);
+float8 __ovld amd_unpack2(uint8);
+float16 __ovld amd_unpack2(uint16);
+
+float __ovld amd_unpack3(uint);
+float2 __ovld amd_unpack3(uint2);
+float3 __ovld amd_unpack3(uint3);
+float4 __ovld amd_unpack3(uint4);
+float8 __ovld amd_unpack3(uint8);
+float16 __ovld amd_unpack3(uint16);
+#endif // cl_amd_media_ops
+
+#ifdef cl_amd_media_ops2
+int __ovld amd_bfe(int src0, uint src1, uint src2);
+int2 __ovld amd_bfe(int2 src0, uint2 src1, uint2 src2);
+int3 __ovld amd_bfe(int3 src0, uint3 src1, uint3 src2);
+int4 __ovld amd_bfe(int4 src0, uint4 src1, uint4 src2);
+int8 __ovld amd_bfe(int8 src0, uint8 src1, uint8 src2);
+int16 __ovld amd_bfe(int16 src0, uint16 src1, uint16 src2);
+
+uint __ovld amd_bfe(uint src0, uint src1, uint src2);
+uint2 __ovld amd_bfe(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_bfe(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_bfe(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_bfe(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_bfe(uint16 src0, uint16 src1, uint16 src2);
+
+uint __ovld amd_bfm(uint src0, uint src1);
+uint2 __ovld amd_bfm(uint2 src0, uint2 src1);
+uint3 __ovld amd_bfm(uint3 src0, uint3 src1);
+uint4 __ovld amd_bfm(uint4 src0, uint4 src1);
+uint8 __ovld amd_bfm(uint8 src0, uint8 src1);
+uint16 __ovld amd_bfm(uint16 src0, uint16 src1);
+
+float __ovld amd_max3(float src0, float src1, float src2);
+float2 __ovld amd_max3(float2 src0, float2 src1, float2 src2);
+float3 __ovld amd_max3(float3 src0, float3 src1, float3 src2);
+float4 __ovld amd_max3(float4 src0, float4 src1, float4 src2);
+float8 __ovld amd_max3(float8 src0, float8 src1, float8 src2);
+float16 __ovld amd_max3(float16 src0, float16 src1, float16 src2);
+
+int __ovld amd_max3(int src0, int src1, int src2);
+int2 __ovld amd_max3(int2 src0, int2 src1, int2 src2);
+int3 __ovld amd_max3(int3 src0, int3 src1, int3 src2);
+int4 __ovld amd_max3(int4 src0, int4 src1, int4 src2);
+int8 __ovld amd_max3(int8 src0, int8 src1, int8 src2);
+int16 __ovld amd_max3(int16 src0, int16 src1, int16 src2);
+
+uint __ovld amd_max3(uint src0, uint src1, uint src2);
+uint2 __ovld amd_max3(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_max3(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_max3(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_max3(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_max3(uint16 src0, uint16 src1, uint16 src2);
+
+float __ovld amd_median3(float src0, float src1, float src2);
+float2 __ovld amd_median3(float2 src0, float2 src1, float2 src2);
+float3 __ovld amd_median3(float3 src0, float3 src1, float3 src2);
+float4 __ovld amd_median3(float4 src0, float4 src1, float4 src2);
+float8 __ovld amd_median3(float8 src0, float8 src1, float8 src2);
+float16 __ovld amd_median3(float16 src0, float16 src1, float16 src2);
+
+int __ovld amd_median3(int src0, int src1, int src2);
+int2 __ovld amd_median3(int2 src0, int2 src1, int2 src2);
+int3 __ovld amd_median3(int3 src0, int3 src1, int3 src2);
+int4 __ovld amd_median3(int4 src0, int4 src1, int4 src2);
+int8 __ovld amd_median3(int8 src0, int8 src1, int8 src2);
+int16 __ovld amd_median3(int16 src0, int16 src1, int16 src2);
+
+uint __ovld amd_median3(uint src0, uint src1, uint src2);
+uint2 __ovld amd_median3(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_median3(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_median3(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_median3(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_median3(uint16 src0, uint16 src1, uint16 src2);
+
+float __ovld amd_min3(float src0, float src1, float src);
+float2 __ovld amd_min3(float2 src0, float2 src1, float2 src);
+float3 __ovld amd_min3(float3 src0, float3 src1, float3 src);
+float4 __ovld amd_min3(float4 src0, float4 src1, float4 src);
+float8 __ovld amd_min3(float8 src0, float8 src1, float8 src);
+float16 __ovld amd_min3(float16 src0, float16 src1, float16 src);
+
+int __ovld amd_min3(int src0, int src1, int src2);
+int2 __ovld amd_min3(int2 src0, int2 src1, int2 src2);
+int3 __ovld amd_min3(int3 src0, int3 src1, int3 src2);
+int4 __ovld amd_min3(int4 src0, int4 src1, int4 src2);
+int8 __ovld amd_min3(int8 src0, int8 src1, int8 src2);
+int16 __ovld amd_min3(int16 src0, int16 src1, int16 src2);
+
+uint __ovld amd_min3(uint src0, uint src1, uint src2);
+uint2 __ovld amd_min3(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_min3(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_min3(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_min3(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_min3(uint16 src0, uint16 src1, uint16 src2);
+
+ulong __ovld amd_mqsad(ulong src0, uint src1, ulong src2);
+ulong2 __ovld amd_mqsad(ulong2 src0, uint2 src1, ulong2 src2);
+ulong3 __ovld amd_mqsad(ulong3 src0, uint3 src1, ulong3 src2);
+ulong4 __ovld amd_mqsad(ulong4 src0, uint4 src1, ulong4 src2);
+ulong8 __ovld amd_mqsad(ulong8 src0, uint8 src1, ulong8 src2);
+ulong16 __ovld amd_mqsad(ulong16 src0, uint16 src1, ulong16 src2);
+
+ulong __ovld amd_qsad(ulong src0, uint src1, ulong src2);
+ulong2 __ovld amd_qsad(ulong2 src0, uint2 src1, ulong2 src2);
+ulong3 __ovld amd_qsad(ulong3 src0, uint3 src1, ulong3 src2);
+ulong4 __ovld amd_qsad(ulong4 src0, uint4 src1, ulong4 src2);
+ulong8 __ovld amd_qsad(ulong8 src0, uint8 src1, ulong8 src2);
+ulong16 __ovld amd_qsad(ulong16 src0, uint16 src1, ulong16 src2);
+
+uint __ovld amd_msad(uint src0, uint src1, uint src2);
+uint2 __ovld amd_msad(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_msad(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_msad(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_msad(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_msad(uint16 src0, uint16 src1, uint16 src2);
+
+uint __ovld amd_sadd(uint src0, uint src1, uint src2);
+uint2 __ovld amd_sadd(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_sadd(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_sadd(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_sadd(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_sadd(uint16 src0, uint16 src1, uint16 src2);
+
+uint __ovld amd_sadw(uint src0, uint src1, uint src2);
+uint2 __ovld amd_sadw(uint2 src0, uint2 src1, uint2 src2);
+uint3 __ovld amd_sadw(uint3 src0, uint3 src1, uint3 src2);
+uint4 __ovld amd_sadw(uint4 src0, uint4 src1, uint4 src2);
+uint8 __ovld amd_sadw(uint8 src0, uint8 src1, uint8 src2);
+uint16 __ovld amd_sadw(uint16 src0, uint16 src1, uint16 src2);
+#endif // cl_amd_media_ops2
+
+#if defined(cl_arm_integer_dot_product_int8)
+uint __ovld arm_dot(uchar4, uchar4);
+int __ovld arm_dot(char4, char4);
+#endif // defined(cl_arm_integer_dot_product_int8)
+
+#if defined(cl_arm_integer_dot_product_accumulate_int8)
+uint __ovld arm_dot_acc(uchar4, uchar4, uint);
+int __ovld arm_dot_acc(char4, char4, int);
+#endif // defined(cl_arm_integer_dot_product_accumulate_int8)
+
+#if defined(cl_arm_integer_dot_product_accumulate_int16)
+uint __ovld arm_dot_acc(ushort2, ushort2, uint);
+int __ovld arm_dot_acc(short2, short2, int);
+#endif // defined(cl_arm_integer_dot_product_accumulate_int16)
+
+#if defined(cl_arm_integer_dot_product_accumulate_saturate_int8)
+uint __ovld arm_dot_acc_sat(uchar4, uchar4, uint);
+int __ovld arm_dot_acc_sat(char4, char4, int);
+#endif // defined(cl_arm_integer_dot_product_accumulate_saturate_int8)
+
+// Disable any extensions we may have enabled previously.
+#pragma OPENCL EXTENSION all : disable
+
+#undef __opencl_c_named_address_space_builtins
+
+#undef __cnfn
+#undef __ovld
+#endif //_OPENCL_H_
diff --git a/drivers/pocl-gen7/share/pocl/include/pocl.h b/drivers/pocl-gen7/share/pocl/include/pocl.h
new file mode 100644
index 0000000..3269f93
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/pocl.h
@@ -0,0 +1,617 @@
+/* pocl.h - global pocl declarations for the host side runtime.
+
+   Copyright (c) 2011 Universidad Rey Juan Carlos
+                 2011-2019 Pekka Jääskeläinen
+                 2024 Pekka Jääskeläinen / Intel Finland Oy
+
+   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.
+*/
+
+/**
+ * @file pocl.h
+ *
+ * The declarations in this file are such that are used both in the
+ * libpocl implementation CL and the kernel compiler. Others should be
+ * moved to pocl_cl.h of lib/CL or under the kernel compiler dir.
+ * @todo Check if there are extra declarations here that could be moved.
+ */
+#ifndef POCL_H
+#define POCL_H
+
+#include <stdint.h>
+
+/* The running number used for identifying PoCL runtime allocated objects.
+   0 marks an invalid/undefined object. */
+typedef uint64_t pocl_obj_id_t;
+
+#if defined(EXPORT_POCL_LIB) && defined(_MSC_VER)
+/* To successfully export OpenCL API, the dllexport must be placed on
+ * both the declaration and the definition as MSVC requires that both
+ * of them have the same attributes.
+ *
+ * NOTE: Trouble is expected if CL/opencl.h is not included for the
+ *       first time here.
+ */
+#undef CL_API_ENTRY
+#define CL_API_ENTRY __declspec(dllexport)
+#endif
+
+#ifndef CL_TARGET_OPENCL_VERSION
+#define CL_TARGET_OPENCL_VERSION 300
+#endif
+#include <CL/opencl.h>
+
+#include "config.h"
+
+#include "pocl_export.h"
+
+#include "pocl_context.h"
+
+#include "vccompat.hpp"
+
+/* The maximum file, directory and path name lengths.
+   NOTE: GDB seems to fail to load symbols from .so files which have
+   longer pathnames than 511, thus the quite small dir/filename length
+   limiter. */
+#define POCL_MAX_DIRNAME_LENGTH 64
+#define POCL_MAX_FILENAME_LENGTH (POCL_MAX_DIRNAME_LENGTH)
+/* -5: Leave space for .so and for additional .o if temp file debugging
+   is enabled. */
+#define POCL_HASH_FILENAME_LENGTH (POCL_MAX_DIRNAME_LENGTH - 5)
+#define POCL_MAX_PATHNAME_LENGTH 4096
+
+/* official Khronos ID */
+#ifndef CL_KHRONOS_VENDOR_ID_POCL
+#define CL_KHRONOS_VENDOR_ID_POCL 0x10006
+#endif
+
+#if __cplusplus >= 201103L
+#  define POCL_ALIGNAS(x) alignas(x)
+#elif __STDC_VERSION__ >= 201112L /* C11 */
+#  define POCL_ALIGNAS(x) _Alignas(x)
+#elif defined(_MSC_VER)
+#  define POCL_ALIGNAS(x) __declspec(align(x))
+#elif defined(__clang__) || defined(__GNUC__)
+#  define POCL_ALIGNAS(x) __attribute__ ((aligned (x)))
+#else
+/* Emit an error for potential correctness issues if alignas() is ignored. */
+#  error "Don't know alignas() counterpart for this compiler!"
+#endif
+
+#ifndef _WIN32
+#define POCL_PATH_SEPARATOR "/"
+#else
+#define POCL_PATH_SEPARATOR "\\"
+#endif
+
+/* Always align buffer allocations, context data, and kernel arguments to
+   sizeof(double16) to enforce easier vectorization for targets with naturally
+   aligned loads/stores. */
+#define MAX_EXTENDED_ALIGNMENT 128
+
+/* represents a single buffer to host memory mapping */
+typedef struct mem_mapping
+{
+  void *host_ptr; /* the location of the mapped buffer chunk in the host memory
+                   */
+  size_t offset;  /* offset to the beginning of the buffer */
+  size_t size;
+  struct mem_mapping *prev, *next;
+
+  /* This is required, because two clEnqueueMap() with the same
+     buffer+size+offset, will create two identical mappings in the
+     buffer->mappings LL. Without this flag, both corresponding clEnqUnmap()s
+     will find the same mapping (the first one in mappings LL), which will lead
+     to memory double-free corruption later. */
+  int unmap_requested;
+
+  cl_map_flags map_flags;
+  /* image mapping data */
+  size_t origin[3];
+  size_t region[3];
+  size_t row_pitch;
+  size_t slice_pitch;
+} mem_mapping_t;
+
+/* A single buffer can and will be allocated in
+   multiple different devices which might or might not share the global memory.
+   This struct captures a single buffer to global memory allocation's
+   properties.
+*/
+typedef struct pocl_mem_identifier
+{
+  /* Global-memory-specific pointer to hardware resource that represents
+     memory. This may be anything, but must be non-NULL while the memory is
+     actually allocated, and NULL when it's not */
+  void *mem_ptr;
+
+  /* If mem_ptr represents an address in the device global memory which
+     is pinned for the lifetime of the buffer. */
+  int is_pinned;
+
+  /* The device-side memory address (if known). If is_pinned is true, this
+     must be a valid value (note: 0 means invalid address). */
+  void *device_addr;
+
+  /* Content version tracking. Every write use (clEnqWriteBuffer,
+   * clMapBuffer(CL_MAP_WRITE), write_only image, read/write buffers as kernel
+   * args etc) increases the version; read uses do not. This version is used in
+   * implicit migrations to find the latest copy of the data.
+   *
+   * In theory, a simple bool of "valid/invalid" could be used;
+   * the only difference is that a version numbering scheme saves history,
+   * which could be useful for LRU global memory garbage collection among other
+   * things in the future.
+   */
+  uint64_t version;
+
+  /* Extra pointer for drivers to use for anything.
+   *
+   * Currently CUDA uses it to track ALLOC_HOST_PTR allocations.
+   * Vulkan uses it to store host-mapped staging memory.
+   */
+  void *extra_ptr;
+
+  /* Extra integer for drivers to use for anything.
+   *
+   * Currently Vulkan uses it to track vulkan memory requirements.
+   */
+  uint64_t extra;
+
+} pocl_mem_identifier;
+
+typedef char pixel_t[16];
+
+typedef struct _mem_destructor_callback mem_destructor_callback_t;
+/* represents a memory object destructor callback */
+struct _mem_destructor_callback
+{
+  void (CL_CALLBACK * pfn_notify) (cl_mem, void*); /* callback function */
+  void *user_data; /* user supplied data passed to callback function */
+  mem_destructor_callback_t *next;
+};
+
+typedef struct _build_program_callback build_program_callback_t;
+struct _build_program_callback
+{
+    void (CL_CALLBACK * callback_function) (cl_program, void*); /* callback function */
+    void *user_data; /* user supplied data passed to callback function */
+};
+
+// same as SHA1_DIGEST_SIZE
+#define POCL_KERNEL_DIGEST_SIZE 20
+typedef uint8_t pocl_kernel_hash_t[POCL_KERNEL_DIGEST_SIZE];
+
+/* For clEnqueueNDRangeKernel(). */
+typedef struct
+{
+  void *hash;
+  void *wg; /* The work group function ptr. Device specific. */
+  cl_kernel kernel;
+  /* The launch data that can be passed to the kernel execution environment. */
+  struct pocl_context pc;
+  struct pocl_argument *arguments;
+  /* Can be used to store/cache arbitrary device-specific data. */
+  void *device_data;
+  /* If set to 1, disallow any work-group function specialization. */
+  int force_generic_wg_func;
+  /* If set to 1, disallow "small grid" WG function specialization. */
+  int force_large_grid_wg_func;
+} _cl_command_run;
+
+/* For clEnqueueCommandBufferKHR(). */
+typedef struct
+{
+  cl_command_buffer_khr buffer;
+} _cl_command_replay;
+
+/* For clEnqueueNativeKernel(). */
+typedef struct
+{
+  void *args;
+  size_t cb_args;
+  /* The argument buffers are stored in _cl_command's migr_info list. */
+  void **arg_locs;
+  void(CL_CALLBACK *user_func) (void *);
+} _cl_command_native;
+
+/* For clEnqueueReadBuffer(). */
+typedef struct
+{
+  void *__restrict__ dst_host_ptr;
+  pocl_mem_identifier *src_content_size_mem_id;
+  size_t offset;
+  size_t size;
+  size_t *content_size;
+  cl_mem src;
+} _cl_command_read;
+
+/* For clEnqueueWriteBuffer(). */
+typedef struct
+{
+  const void *__restrict__ src_host_ptr;
+  size_t offset;
+  size_t size;
+  cl_mem dst;
+} _cl_command_write;
+
+/* For clEnqueueCopyBuffer(). */
+typedef struct
+{
+  pocl_mem_identifier *src_content_size_mem_id;
+  cl_mem src;
+  cl_mem src_content_size;
+  cl_mem dst;
+  size_t src_offset;
+  size_t dst_offset;
+  size_t size;
+} _cl_command_copy;
+
+/* For clEnqueueReadBufferRect(). */
+typedef struct
+{
+  void *__restrict__ dst_host_ptr;
+  size_t buffer_origin[3];
+  size_t host_origin[3];
+  size_t region[3];
+  size_t buffer_row_pitch;
+  size_t buffer_slice_pitch;
+  size_t host_row_pitch;
+  size_t host_slice_pitch;
+  cl_mem src;
+} _cl_command_read_rect;
+
+/* For clEnqueueWriteBufferRect(). */
+typedef struct
+{
+  const void *__restrict__ src_host_ptr;
+  size_t buffer_origin[3];
+  size_t host_origin[3];
+  size_t region[3];
+  size_t buffer_row_pitch;
+  size_t buffer_slice_pitch;
+  size_t host_row_pitch;
+  size_t host_slice_pitch;
+  cl_mem dst;
+} _cl_command_write_rect;
+
+/* For clEnqueueCopyBufferRect(). */
+typedef struct
+{
+  cl_mem src;
+  cl_mem dst;
+  size_t dst_origin[3];
+  size_t src_origin[3];
+  size_t region[3];
+  size_t src_row_pitch;
+  size_t src_slice_pitch;
+  size_t dst_row_pitch;
+  size_t dst_slice_pitch;
+} _cl_command_copy_rect;
+
+/* For clEnqueueMapBuffer(). */
+typedef struct
+{
+  mem_mapping_t *mapping;
+  cl_mem buffer;
+} _cl_command_map;
+
+/* For clEnqueueUnMapMemObject(). */
+typedef struct
+{
+  mem_mapping_t *mapping;
+  cl_mem buffer;
+} _cl_command_unmap;
+
+/* For clEnqueueFillBuffer(). */
+typedef struct
+{
+  size_t size;
+  size_t offset;
+  void *__restrict__ pattern;
+  size_t pattern_size;
+  cl_mem dst;
+} _cl_command_fill_mem;
+
+/* For clEnqueue(Write/Read)Image(). */
+typedef struct
+{
+  void *__restrict__ dst_host_ptr;
+  cl_mem src;
+  cl_mem dst;
+  size_t dst_offset;
+  size_t origin[3];
+  size_t region[3];
+  size_t dst_row_pitch;
+  size_t dst_slice_pitch;
+} _cl_command_read_image;
+
+typedef struct
+{
+  const void *__restrict__ src_host_ptr;
+  cl_mem src;
+  cl_mem dst;
+  size_t src_offset;
+  size_t origin[3];
+  size_t region[3];
+  size_t src_row_pitch;
+  size_t src_slice_pitch;
+} _cl_command_write_image;
+
+typedef struct
+{
+  cl_mem src;
+  cl_mem dst;
+  size_t dst_origin[3];
+  size_t src_origin[3];
+  size_t region[3];
+} _cl_command_copy_image;
+
+/* For clEnqueueFillImage(). */
+typedef struct
+{
+  pixel_t fill_pixel;
+  cl_uint4 orig_pixel;
+  size_t pixel_size;
+  size_t origin[3];
+  size_t region[3];
+  cl_mem dst;
+} _cl_command_fill_image;
+
+/* For clEnqueueMarkerWithWaitlist(). */
+typedef struct
+{
+  void *data;
+  int has_wait_list;
+} _cl_command_marker;
+
+/* For clEnqueueBarrierWithWaitlist(). */
+typedef _cl_command_marker _cl_command_barrier;
+
+typedef enum pocl_migration_type_e {
+  ENQUEUE_MIGRATE_TYPE_NOP,
+  ENQUEUE_MIGRATE_TYPE_D2H,
+  ENQUEUE_MIGRATE_TYPE_H2D,
+  ENQUEUE_MIGRATE_TYPE_D2D
+} pocl_migration_type_t;
+
+/* For clEnqueueMigrateMemObjects(). */
+typedef struct
+{
+  pocl_migration_type_t type;
+  cl_device_id src_device;
+  /** For migrating a buffer that has a size buffer as per
+   * cl_pocl_content_size */
+  uint64_t migration_size;
+  pocl_mem_identifier *src_content_size_mem_id;
+  /* Number of buffers to migrate. The actual buffers are in migr_info in
+     the _cl_command_node. */
+  size_t num_buffers;
+  /* Set to 1 if this is a migration command generated by the runtime to
+     ensure coherence for the input buffers of commands. */
+  char implicit;
+} _cl_command_migrate;
+
+typedef struct
+{
+  void* data;
+  cl_command_queue queue;
+  unsigned  num_svm_pointers;
+  void  **svm_pointers;
+  void (CL_CALLBACK  *pfn_free_func) ( cl_command_queue queue,
+                                       unsigned num_svm_pointers,
+                                       void *svm_pointers[],
+                                       void  *user_data);
+} _cl_command_svm_free;
+
+typedef struct
+{
+  unsigned num_svm_pointers;
+  size_t *sizes;
+  void **svm_pointers;
+} _cl_command_svm_migrate;
+
+typedef struct
+{
+  void* svm_ptr;
+  size_t size;
+  cl_map_flags flags;
+} _cl_command_svm_map;
+
+typedef struct
+{
+  void* svm_ptr;
+  size_t size;
+} _cl_command_svm_unmap;
+
+typedef struct
+{
+  const void *__restrict__ src;
+  void *__restrict__ dst;
+  size_t size;
+} _cl_command_svm_cpy;
+
+typedef struct
+{
+  const void *__restrict__ src;
+  void *__restrict__ dst;
+  size_t region[3];
+  size_t src_origin[3];
+  size_t dst_origin[3];
+  size_t src_row_pitch;
+  size_t src_slice_pitch;
+  size_t dst_row_pitch;
+  size_t dst_slice_pitch;
+} _cl_command_svm_cpy_rect;
+
+typedef struct
+{
+  void *__restrict__ svm_ptr;
+  size_t size;
+  void *__restrict__ pattern;
+  size_t pattern_size;
+} _cl_command_svm_fill;
+
+typedef struct
+{
+  void *__restrict__ svm_ptr;
+  void *__restrict__ pattern;
+  size_t region[3];
+  size_t origin[3];
+  size_t row_pitch;
+  size_t slice_pitch;
+  size_t pattern_size;
+} _cl_command_svm_fill_rect;
+
+typedef struct
+{
+  const void *ptr;
+  size_t size;
+  cl_mem_advice_intel advice;
+} _cl_command_svm_memadvise;
+
+typedef union
+{
+  _cl_command_run run;
+  _cl_command_native native;
+  _cl_command_replay replay;
+
+  _cl_command_read read;
+  _cl_command_write write;
+  _cl_command_copy copy;
+  _cl_command_read_rect read_rect;
+  _cl_command_write_rect write_rect;
+  _cl_command_copy_rect copy_rect;
+  _cl_command_fill_mem memfill;
+
+  _cl_command_read_image read_image;
+  _cl_command_write_image write_image;
+  _cl_command_copy_image copy_image;
+  _cl_command_fill_image fill_image;
+
+  _cl_command_map map;
+  _cl_command_unmap unmap;
+
+  _cl_command_marker marker;
+  _cl_command_barrier barrier;
+  _cl_command_migrate migrate;
+
+  _cl_command_svm_free svm_free;
+  _cl_command_svm_map svm_map;
+  _cl_command_svm_unmap svm_unmap;
+  _cl_command_svm_cpy svm_memcpy;
+  _cl_command_svm_cpy_rect svm_memcpy_rect;
+  _cl_command_svm_fill svm_fill;
+  _cl_command_svm_fill_rect svm_fill_rect;
+  _cl_command_svm_migrate svm_migrate;
+
+  _cl_command_svm_memadvise mem_advise;
+} _cl_command_t;
+
+typedef struct _pocl_buffer_migration_info
+  pocl_buffer_migration_info;
+
+/**
+ * Enum that represents different possible states of a command node.
+ */
+typedef enum
+{
+  POCL_COMMAND_FAILED = -1,
+  /* Default unless set to ready. */
+  POCL_COMMAND_NOT_READY = 0,
+  POCL_COMMAND_READY = 1,
+} pocl_command_state;
+
+/* One item in a command queue or a command buffer. */
+typedef struct _cl_command_node _cl_command_node;
+struct _cl_command_node
+{
+  _cl_command_t command;
+  cl_command_type type;
+  _cl_command_node *next; // for linked-list storage
+  _cl_command_node *prev;
+
+  /***
+   * Command buffers use sync points as a template for synchronizing commands
+   * within the buffer. Commands outside the buffer can't depend on sync points
+   * and individual commands in the buffer can't depend on events. Because this
+   * struct is used both for recorded and immediately enqueued commands, the
+   * two synchronization mechanisms are made mutually exclusive here.
+   * */
+  union
+  {
+    struct
+    {
+      cl_event event;
+    } event;
+    struct
+    {
+      cl_sync_point_khr sync_point;
+      cl_uint num_sync_points_in_wait_list;
+      cl_sync_point_khr *sync_point_wait_list;
+    } syncpoint;
+  } sync;
+  cl_device_id device;
+  /* The index of the targeted device in the **program** device list. */
+  unsigned program_device_i;
+
+  /* Used to indicate if a node is ready to be executed or failed. */
+  pocl_command_state state;
+
+  /* true if the node belongs to a cl_command_buffer_khr */
+  cl_int buffered;
+
+  /* Which of the command queues in the command buffer's queue list
+   * this command was recorded for. */
+  cl_uint queue_idx;
+  /* List of buffers this command accesses, used for inserting migrations */
+  pocl_buffer_migration_info *migr_infos;
+
+  /* back pointer to the command buffer, when this command is recorded
+   * in a cl_khr_command_buffer. NULL for other (non-buffered) commands */
+  cl_command_buffer_khr cmd_buffer;
+};
+
+/**
+ * Enumeration for different modes of converting automatic locals
+ */
+typedef enum
+{
+  POCL_AUTOLOCALS_TO_ARGS_NEVER = 0,
+  POCL_AUTOLOCALS_TO_ARGS_ALWAYS = 1,
+  /* convert autolocals to args only if there are dynamic local memory
+   * function arguments in the kernel. */
+  POCL_AUTOLOCALS_TO_ARGS_ONLY_IF_DYNAMIC_LOCALS_PRESENT = 2,
+} pocl_autolocals_to_args_strategy;
+
+typedef struct pocl_version_t
+{
+  unsigned major;
+  unsigned minor;
+
+#ifdef __cplusplus
+  pocl_version_t () : major{0}, minor{0} {}
+  pocl_version_t (unsigned the_major, unsigned the_minor)
+    : major{the_major}, minor{the_minor}
+  {
+  }
+#endif
+} pocl_version_t;
+
+#endif /* POCL_H */
diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_device.h b/drivers/pocl-gen7/share/pocl/include/pocl_device.h
new file mode 100644
index 0000000..2418fac
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/pocl_device.h
@@ -0,0 +1,78 @@
+/* pocl_device.h - global pocl declarations to be used in the device binaries in
+                   case applicable by the target
+
+   Copyright (c) 2012-2018 Pekka Jääskeläinen / Tampere University of Technology
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+*/
+
+#ifndef POCL_DEVICE_H
+#define POCL_DEVICE_H
+
+#include "pocl_types.h"
+
+#define MAX_KERNEL_ARGS 64
+#define MAX_KERNEL_NAME_LENGTH 64
+
+/* Metadata of a single kernel stored in the device.*/
+typedef struct {
+    const uchar name[MAX_KERNEL_NAME_LENGTH];
+    ushort num_args;
+    ushort num_locals;
+    void *work_group_func;
+} __kernel_metadata;
+
+#ifdef _MSC_VER
+  #define ALIGN4(x) __declspec(align(4)) x
+  #define ALIGN8(x) __declspec(align(4)) x
+#else
+  #define ALIGN4(x) x __attribute__ ((aligned (4)))
+  #define ALIGN8(x) x __attribute__ ((aligned (8)))
+#endif
+
+/* A kernel invocation command. */
+typedef struct {
+    /* The kernel to execute. Points to the metadata in the device global
+       memory. It will be casted to a __kernel_metadata* */
+    ALIGN8 (uint kernel_meta);
+    /* Pointer to the kernel arguments in the local memory. Will be
+       casted to 32 bit void* */
+    ALIGN8 (uint args);
+    ALIGN8 (uint args_size);
+    /* pocl context */
+    ALIGN8 (uint ctx);
+    ALIGN8 (uint ctx_size);
+    /* The execution status of this queue slot. */
+    ALIGN8 (uint status);
+} __kernel_exec_cmd;
+
+/* Kernel execution statuses. */
+
+/* The invocation entry is free to use. */
+#define POCL_KST_FREE     1
+/* The kernel structure has been populated and is waiting to be
+   executed. */
+#define POCL_KST_READY    2
+/* The kernel is currently running in the device. */
+#define POCL_KST_RUNNING  3
+/* The kernel has finished execution. The results can be collected and the
+   execution entry be freed (by writing POCL_KST_FREE to the status). */
+#define POCL_KST_FINISHED 4
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_image_types.h b/drivers/pocl-gen7/share/pocl/include/pocl_image_types.h
new file mode 100644
index 0000000..a8db3c7
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/pocl_image_types.h
@@ -0,0 +1,52 @@
+/* pocl_image_types.h - image data structure used by device implementations
+
+   Copyright (c) 2013 Ville Korhonen
+   Copyright (c) 2017 Michal Babej / Tampere University of Technology
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+*/
+
+#ifndef __X86_IMAGE_H__
+#define __X86_IMAGE_H__
+
+#ifdef __CBUILD__
+#define INTTYPE cl_int
+#else
+#define INTTYPE int
+#endif
+
+typedef uintptr_t dev_sampler_t;
+
+typedef struct dev_image_t {
+  void *_data;
+  INTTYPE _width;
+  INTTYPE _height;
+  INTTYPE _depth;
+  INTTYPE _image_array_size;
+  INTTYPE _row_pitch;
+  INTTYPE _slice_pitch;
+  INTTYPE _num_mip_levels; /* maybe not needed */
+  INTTYPE _num_samples;    /* maybe not needed */
+  INTTYPE _order;
+  INTTYPE _data_type;
+  INTTYPE _num_channels;
+  INTTYPE _elem_size;
+} dev_image_t;
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_spir.h b/drivers/pocl-gen7/share/pocl/include/pocl_spir.h
new file mode 100644
index 0000000..0dd1f92
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/pocl_spir.h
@@ -0,0 +1,33 @@
+/* pocl-spir.h - global pocl declarations for the SPIR(-V) support.
+
+   Copyright (c) 2018-2022 Pekka Jääskeläinen
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to
+   deal in the Software without restriction, including without limitation the
+   rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+   sell copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+   IN THE SOFTWARE.
+*/
+
+#ifndef POCL_SPIR_H
+#define POCL_SPIR_H
+
+#define SPIR_ADDRESS_SPACE_PRIVATE 0
+#define SPIR_ADDRESS_SPACE_GLOBAL 1
+#define SPIR_ADDRESS_SPACE_CONSTANT 2
+#define SPIR_ADDRESS_SPACE_LOCAL 3
+#define SPIR_ADDRESS_SPACE_GENERIC 4
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_types.h b/drivers/pocl-gen7/share/pocl/include/pocl_types.h
new file mode 100644
index 0000000..7bc5c3f
--- /dev/null
+++ b/drivers/pocl-gen7/share/pocl/include/pocl_types.h
@@ -0,0 +1,179 @@
+/* pocl_types.h - The basic OpenCL C device side scalar data types.
+
+   Copyright (c) 2018 Pekka Jääskeläinen / Tampere University of Technology
+
+   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 header is designed to be included both from the device and the host.
+   In case compiling OpenCL C sources, __OPENCL_VERSION__ should be set.
+   In case compiling in the host, all but the device-specific types are
+   defined (size_t and others). Devices should avoid including the C
+   stdint.h instead of this one as OpenCL C size_t et al. is allowed to
+   be of different width than when targeting C.
+
+   TODO: replace this header (partially) with Clang's opencl-c.h
+*/
+
+#ifndef POCL_DEVICE_TYPES_H
+#define POCL_DEVICE_TYPES_H
+
+#ifdef __OPENCL_VERSION__
+
+/* required for LLVM 13+ */
+typedef unsigned reserve_id_t;
+
+#ifdef __USE_CLANG_OPENCL_C_H
+
+/* Minimal definitions, only the target specific macro overrides,
+   just in case Clang export the C ones which might differ for
+   OpenCL C. */
+
+#ifdef __INTPTR_TYPE__
+#undef __INTPTR_TYPE__
+#endif
+
+#ifdef __UINTPTR_TYPE__
+#undef __UINTPTR_TYPE__
+#endif
+
+#ifdef __SIZE_TYPE__
+#undef __SIZE_TYPE__
+#endif
+
+#ifdef __SIZE_MAX__
+#undef __SIZE_MAX__
+#endif
+
+#if defined(POCL_DEVICE_ADDRESS_BITS) && POCL_DEVICE_ADDRESS_BITS == 32
+#define __SIZE_TYPE__ uint
+#define __SIZE_MAX__ UINT_MAX
+#define __INTPTR_TYPE__ int
+#define __UINTPTR_TYPE__ uint
+#else
+#define __SIZE_TYPE__ ulong
+#define __SIZE_MAX__ ULONG_MAX
+#define __INTPTR_TYPE__ long
+#define __UINTPTR_TYPE__ ulong
+#endif
+
+
+
+#else
+
+/* Compiling Device-specific OpenCL C or builtin library C. */
+
+#if defined cl_khr_fp64 && !defined cl_khr_int64
+#error "cl_khr_fp64 requires cl_khr_int64"
+#endif
+
+/* TODO FIXME We should not use these in OpenCL library's C code at all.
+ * The problem is that 1) these are predefined by glibc, 2) while we can
+ * re-define "ulong", we cannot control the size of "long" at all.
+ * which can lead to "ulong" being 64bit and "long" 32bit, resulting in
+ * mysterious errors and bugs. Therefore OpenCL library's C code should
+ * use the fixed size C types where integer size matters. */
+
+#ifdef __CBUILD__
+
+/* Builtin library C code definitions. */
+
+#define size_t csize_t
+#define uintptr_t cuintptr_t
+#define intptr_t cintptr_t
+
+#include <stdint.h>
+
+#undef size_t
+#undef uintptr_t
+#undef intptr_t
+
+typedef uint8_t uchar;
+typedef uint16_t ushort;
+typedef uint32_t uint;
+
+#ifdef cl_khr_int64
+#if __APPLE__
+typedef unsigned long ulong;
+#else
+typedef uint64_t ulong;
+#endif
+#else
+typedef uint32_t ulong;
+#endif
+
+#endif
+
+/* The definitions below intentionally lead to errors if these types
+   are used when they are not available in the language. This prevents
+   accidentally using them if the compiler does not disable these
+   types, but only e.g. defines them with an incorrect size.*/
+
+#ifndef cl_khr_fp64
+typedef struct error_undefined_type_double error_undefined_type_double;
+#define double error_undefined_type_double
+#endif
+
+#ifdef __SIZE_TYPE__
+#undef __SIZE_TYPE__
+#endif
+
+#ifdef __SIZE_MAX__
+#undef __SIZE_MAX__
+#endif
+
+#if defined(POCL_DEVICE_ADDRESS_BITS) && POCL_DEVICE_ADDRESS_BITS == 32
+#define __SIZE_TYPE__ uint
+#define __SIZE_MAX__ UINT_MAX
+#else
+#define __SIZE_TYPE__ ulong
+#define __SIZE_MAX__ ULONG_MAX
+#endif
+
+typedef __SIZE_TYPE__ size_t;
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef ptrdiff_t intptr_t;
+typedef size_t uintptr_t;
+
+#endif /* #ifdef __USE_CLANG_OPENCL_C_H */
+
+#else /* #ifdef __OPENCL_VERSION__ */
+
+/* Including from a host source (runtime API implementation). Introduce
+   the fixed width datatypes, but do not override C's size_t and other
+   target specific datatypes. */
+
+typedef unsigned char uchar;
+
+/* FIXME see the above TODO about these types. */
+
+#if !(defined(_SYS_TYPES_H) && defined(__USE_MISC))
+/* glibc, when including sys/types.h, typedefs these. */
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+
+#endif
+
+#include <stdint.h>
+
+#endif
+
+#endif
diff --git a/drivers/pocl-gen7/share/pocl/kernel-x86_64-unknown-linux-gnu-ivybridge.bc b/drivers/pocl-gen7/share/pocl/kernel-x86_64-unknown-linux-gnu-ivybridge.bc
new file mode 100644
index 0000000..76f8942
Binary files /dev/null and b/drivers/pocl-gen7/share/pocl/kernel-x86_64-unknown-linux-gnu-ivybridge.bc differ
diff --git a/flake.lock b/flake.lock
index 1ffee94..fee38fb 100755
--- a/flake.lock
+++ b/flake.lock
@@ -720,14 +720,17 @@
         ]
       },
       "locked": {
-        "lastModified": 1791142268,
-        "narHash": "sha256-iVe30p3s0ZmjjUlfzNPoBrXRsi1UEdpN7GBBDKJUXfw=",
-        "path": "/home/elars/Projects/valw",
-        "type": "path"
+        "lastModified": 1791550319,
+        "narHash": "sha256-GDO12cDMXhyQycIoyuznQFFO0wzarnxRlzJryA120jU=",
+        "owner": "elwrcl",
+        "repo": "valw",
+        "rev": "e320f7a1b6d2e2f3dafd096af8668c99ac488be2",
+        "type": "github"
       },
       "original": {
-        "path": "/home/elars/Projects/valw",
-        "type": "path"
+        "owner": "elwrcl",
+        "repo": "valw",
+        "type": "github"
       }
     },
     "xwayland-satellite-stable": {
diff --git a/flake.nix b/flake.nix
index 7141043..b180d16 100644
--- a/flake.nix
+++ b/flake.nix
@@ -78,7 +78,7 @@
       url = "github:elwrcl/scx_soryu";
     };
     valw = {
-      url = "path:/home/elars/Projects/valw";
+      url = "github:elwrcl/valw";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.flake-parts.follows = "flake-parts";
     };
diff --git a/hosts/copland.ulu.nix b/hosts/copland.ulu.nix
index d0995e2..6b672d6 100644
--- a/hosts/copland.ulu.nix
+++ b/hosts/copland.ulu.nix
@@ -88,6 +88,9 @@ in
               config.flake.homeModules.home-nyi
               config.flake.homeModules.home-valw
               config.flake.homeModules.home-discord
+              config.flake.homeModules.home-mpv
+              config.flake.homeModules.home-mpv-intel-hard
+              config.flake.homeModules.home-mpv-svp
               config.flake.homeModules.home-noctalia
               config.flake.homeModules.desktop-niri-home
               config.flake.homeModules.desktop-niri-package
@@ -118,6 +121,7 @@ in
       config.flake.nixosModules.hw-bluetooth
       config.flake.nixosModules.hw-graphics
       config.flake.nixosModules.hw-intel-hard
+      config.flake.nixosModules.hw-ivb-drivers
       config.flake.nixosModules.hw-udev
       config.flake.nixosModules.net-network-manager
       config.flake.nixosModules.net-dpi-evasion
diff --git a/modules/home/home-mpv-intel-hard.ulu.nix b/modules/home/home-mpv-intel-hard.ulu.nix
new file mode 100644
index 0000000..7286c3d
--- /dev/null
+++ b/modules/home/home-mpv-intel-hard.ulu.nix
@@ -0,0 +1,28 @@
+{ ... }:
+{
+  flake.homeModules.home-mpv-intel-hard =
+    {
+      lib,
+      pkgs,
+      inputs,
+      osConfig,
+      ...
+    }:
+    let
+      cfg = osConfig.programs.intel-hard;
+      vk = (import "${inputs.intel-hard}/graphics").${cfg.vulkan.driver};
+      icd = "${cfg.buildRoot}/${vk.icd}";
+      runtimeLibPath = lib.makeLibraryPath (import "${inputs.intel-hard}/lib/runtime-libs.nix" pkgs);
+    in
+    {
+      elars.mpv.wrapperRun = lib.mkIf cfg.enable ''
+        if [ -f "${icd}" ]; then
+          export VK_DRIVER_FILES="${icd}"
+          export VK_ICD_FILENAMES="${icd}"
+          export MESA_VK_DEVICE_SELECT="${cfg.pciId}"
+          export LD_LIBRARY_PATH="${runtimeLibPath}''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+          unset MESA_GL_VERSION_OVERRIDE
+        fi
+      '';
+    };
+}
diff --git a/modules/home/home-mpv-svp.ulu.nix b/modules/home/home-mpv-svp.ulu.nix
new file mode 100644
index 0000000..7355a20
--- /dev/null
+++ b/modules/home/home-mpv-svp.ulu.nix
@@ -0,0 +1,97 @@
+{ ... }:
+{
+  flake.homeModules.home-mpv-svp =
+    { pkgs, ... }:
+    let
+      # Only the free SVPflow plugins are taken from the SVP 4 bundle;
+      # the paid SVP Manager is not used.
+      svpflow = pkgs.stdenv.mkDerivation (finalAttrs: {
+        pname = "svpflow";
+        version = "4.7.305";
+        src = pkgs.fetchurl {
+          url = "https://www.svp-team.com/files/svp4-linux.${finalAttrs.version}.tar.bz2";
+          hash = "sha256-PWAcm/hIA4JH2QtJPP+gSJdJLRdfdbZXIVdWELazbxQ=";
+        };
+
+        nativeBuildInputs = [
+          pkgs.p7zip
+          pkgs.autoPatchelfHook
+        ];
+        buildInputs = [ (pkgs.lib.getLib pkgs.stdenv.cc.cc) ];
+
+        unpackPhase = ''
+          tar xf $src
+        '';
+
+        # The .run installer is a stack of 7z archives; extract them all.
+        buildPhase = ''
+          mkdir installer extracted
+          LANG=C grep --only-matching --byte-offset --binary --text $'7z\xBC\xAF\x27\x1C' svp4-linux.run |
+            cut -f1 -d: |
+            while read ofs; do
+              dd if=svp4-linux.run bs=1M iflag=skip_bytes status=none skip=$ofs of="installer/bin-$ofs.7z"
+            done
+          for f in installer/*.7z; do
+            7z -bd -bb0 -y x -oextracted "$f" || true
+          done
+        '';
+
+        installPhase = ''
+          install -Dm755 -t $out/lib extracted/plugins/libsvpflow1.so extracted/plugins/libsvpflow2.so
+        '';
+
+        meta.license = pkgs.lib.licenses.unfree;
+      });
+
+      script = pkgs.writeText "svp.vpy" ''
+        import vapoursynth as vs
+
+        core = vs.core
+        core.std.LoadPlugin("${svpflow}/lib/libsvpflow1.so")
+        core.std.LoadPlugin("${svpflow}/lib/libsvpflow2.so")
+
+        clip = video_in
+        src_fps = container_fps if container_fps > 0.1 else 23.976
+
+        if clip.format.id != vs.YUV420P8:
+            clip = clip.resize.Point(format=vs.YUV420P8, dither_type="ordered")
+
+        if clip.height > 720:
+            clip = clip.resize.Bilinear(round(clip.width * 720 / clip.height / 2) * 2, 720)
+
+        sup = core.svp1.Super(clip, "{pel:1,gpu:1}")
+        vec = core.svp1.Analyse(
+            sup["clip"], sup["data"], clip,
+            "{block:{w:32,h:32,overlap:0},main:{search:{coarse:{distance:0}}},refine:[{thsad:200}]}",
+        )
+        smooth = core.svp2.SmoothFps(
+            clip, sup["clip"], sup["data"], vec["clip"], vec["data"],
+            "{rate:{num:60,den:1,abs:true},algo:13,scene:{}}", src=clip, fps=src_fps,
+        )
+        smooth.set_output()
+      '';
+    in
+    {
+      elars.mpv.vapoursynth = true;
+
+      programs.mpv = {
+        profiles.svp = {
+          profile-cond = ''get("user-data/svp", "yes") == "yes" and get("container-fps", 0) < 40'';
+          profile-restore = "copy";
+          hwdec = "vaapi";
+          scale = "bicubic";
+          deinterlace = "auto";
+          vf-add = "lavfi=[scale_vaapi=w=-2:h='min(720,ih)':format=nv12,hwdownload,format=nv12],vapoursynth=${script}:buffered-frames=4:concurrent-frames=4";
+        };
+      };
+
+      xdg.configFile."mpv/scripts/svp-toggle.lua".text = ''
+        mp.set_property_native("user-data/svp", "yes")
+        mp.add_key_binding("alt+s", "svp-toggle", function()
+          local on = mp.get_property_native("user-data/svp") ~= "yes"
+          mp.set_property_native("user-data/svp", on and "yes" or "no")
+          mp.osd_message("SVP: " .. (on and "on" or "off"))
+        end)
+      '';
+    };
+}
diff --git a/modules/home/home-mpv.ulu.nix b/modules/home/home-mpv.ulu.nix
new file mode 100644
index 0000000..aac8f95
--- /dev/null
+++ b/modules/home/home-mpv.ulu.nix
@@ -0,0 +1,63 @@
+{ ... }:
+{
+  flake.homeModules.home-mpv =
+    {
+      lib,
+      pkgs,
+      config,
+      ...
+    }:
+    let
+      cfg = config.elars.mpv;
+      withScripts = pkgs.mpv.override {
+        mpv-unwrapped =
+          if cfg.vapoursynth then
+            pkgs.mpv-unwrapped.override { vapoursynthSupport = true; }
+          else
+            pkgs.mpv-unwrapped;
+        scripts = with pkgs.mpvScripts; [
+          uosc
+          thumbfast
+          autoload
+          mpris
+          memo
+          quality-menu
+          sponsorblock-minimal
+          reload
+        ];
+      };
+    in
+    {
+      options.elars.mpv.wrapperRun = lib.mkOption {
+        type = lib.types.lines;
+        default = "";
+        description = "Shell snippet run by the mpv wrapper before exec.";
+      };
+
+      options.elars.mpv.vapoursynth = lib.mkEnableOption "VapourSynth filter support in mpv";
+
+      config.programs.mpv = {
+        enable = true;
+
+        package =
+          if cfg.wrapperRun == "" then
+            withScripts
+          else
+            pkgs.symlinkJoin {
+              name = "mpv-wrapped";
+              paths = [ withScripts ];
+              nativeBuildInputs = [ pkgs.makeShellWrapper ];
+              postBuild = ''
+                wrapProgramShell $out/bin/mpv --run ${lib.escapeShellArg cfg.wrapperRun}
+              '';
+            };
+
+        config = {
+          hwdec = "vulkan,vaapi";
+          hwdec-codecs = "all";
+          osc = "no";
+          osd-bar = "no";
+        };
+      };
+    };
+}
diff --git a/modules/nixos/common/common-git.ulu.nix b/modules/nixos/common/common-git.ulu.nix
index 0e4950d..c392085 100644
--- a/modules/nixos/common/common-git.ulu.nix
+++ b/modules/nixos/common/common-git.ulu.nix
@@ -1,7 +1,7 @@
 { ... }:
 {
   commonModules.common-git =
-    { pkgs, lib, ... }:
+    { pkgs, ... }:
     let
       base = ''
         [user]
@@ -19,7 +19,14 @@
         	helper = osxkeychain
       '';
 
-      gitconfig = pkgs.writeText "gitconfig" (base + lib.optionalString pkgs.stdenv.isDarwin darwinExtra);
+      linuxExtra = ''
+        [credential]
+        	helper = ${pkgs.gitFull}/bin/git-credential-libsecret
+      '';
+
+      gitconfig = pkgs.writeText "gitconfig" (
+        base + (if pkgs.stdenv.isDarwin then darwinExtra else linuxExtra)
+      );
     in
     {
       environment.variables.GIT_CONFIG_SYSTEM = "${gitconfig}";
diff --git a/modules/nixos/common/common-nix.ulu.nix b/modules/nixos/common/common-nix.ulu.nix
index 0192127..d0f01f6 100644
--- a/modules/nixos/common/common-nix.ulu.nix
+++ b/modules/nixos/common/common-nix.ulu.nix
@@ -14,7 +14,7 @@
           "pipe-operators"
         ];
         max-jobs = 2;
-        cores = 2;
+        cores = 0;
 
         min-free = 5368709120; # 5 GiB
         max-free = 21474836480; # 20 GiB
@@ -46,12 +46,6 @@
         persistent = true;
         randomizedDelaySec = "45min";
       };
-      nix.optimise = {
-        automatic = true;
-        dates = [ "monthly" ];
-        persistent = true;
-        randomizedDelaySec = "45min";
-      };
 
       documentation = {
         man.enable = true;
diff --git a/modules/nixos/common/common-packages.ulu.nix b/modules/nixos/common/common-packages.ulu.nix
index 97f8237..a89a61f 100644
--- a/modules/nixos/common/common-packages.ulu.nix
+++ b/modules/nixos/common/common-packages.ulu.nix
@@ -18,6 +18,7 @@
         onlyoffice-desktopeditors
         kdePackages.kdenlive
         whatsapp-electron
+        qbittorrent
         telegram-desktop
         prismlauncher
         gparted-full
@@ -178,7 +179,6 @@
         ffmpeg
         yt-dlp
         cava
-        mpv
 
         inputs.agenix.packages.${system}.default
         inputs.nix-alien.packages.${system}.nix-alien
diff --git a/modules/nixos/desktop/desktop-xdg-mime.ulu.nix b/modules/nixos/desktop/desktop-xdg-mime.ulu.nix
index 0f60745..f3f76aa 100644
--- a/modules/nixos/desktop/desktop-xdg-mime.ulu.nix
+++ b/modules/nixos/desktop/desktop-xdg-mime.ulu.nix
@@ -15,6 +15,8 @@
             "x-scheme-handler/about" = "helium.desktop";
             "x-scheme-handler/unknown" = "helium.desktop";
             "x-scheme-handler/steam" = "steam.desktop";
+            "x-scheme-handler/magnet" = "org.qbittorrent.qBittorrent.desktop";
+            "application/x-bittorrent" = "org.qbittorrent.qBittorrent.desktop";
 
             # media
             "image/png" = "org.gnome.Loupe.desktop";
diff --git a/modules/nixos/hw/hw-graphics.ulu.nix b/modules/nixos/hw/hw-graphics.ulu.nix
index d9ff126..3a82d16 100644
--- a/modules/nixos/hw/hw-graphics.ulu.nix
+++ b/modules/nixos/hw/hw-graphics.ulu.nix
@@ -45,7 +45,7 @@
             extraPackages = [
               wayland-intel-vaapi-driver
               pkgs.libvdpau-va-gl
-              pkgs.pocl
+              # OpenCL (GPU + CPU): pocl-gen7 in hw-ivb-drivers
             ];
             extraPackages32 = [
               wayland-intel-vaapi-driver-32
diff --git a/modules/nixos/hw/hw-ivb-drivers.ulu.nix b/modules/nixos/hw/hw-ivb-drivers.ulu.nix
new file mode 100644
index 0000000..1360134
--- /dev/null
+++ b/modules/nixos/hw/hw-ivb-drivers.ulu.nix
@@ -0,0 +1,115 @@
+{ ... }:
+{
+  flake.nixosModules.hw-ivb-drivers =
+    { pkgs, ... }:
+    let
+      drivers =
+        p: arch:
+        p.stdenv.mkDerivation {
+          pname = "ivb-drivers";
+          version = "fork";
+          src = ../../../drivers/ivb + "/${arch}";
+
+          nativeBuildInputs = [ p.autoPatchelfHook ];
+          buildInputs = with p; [
+            libdrm
+            zstd
+            expat
+            libxcb
+            libx11
+            libxshmfence
+            xcbutilkeysyms
+            wayland
+            llvmPackages_21.llvm.lib
+            llvmPackages_21.libclang.lib
+            spirv-llvm-translator
+            stdenv.cc.cc.lib
+          ];
+          dontStrip = true; # stripped by meson install
+
+          installPhase = ''
+            runHook preInstall
+            mkdir -p $out/lib/d3d $out/share/vulkan/icd.d
+            install -m 0755 libvulkan_intel_hasvk13.so $out/lib/
+            install -m 0755 d3dadapter9.so.1 $out/lib/d3d/
+            ln -s d3dadapter9.so.1 $out/lib/d3d/d3dadapter9.so
+
+            cat > $out/share/vulkan/icd.d/intel_hasvk_ivb_icd.${arch}.json <<EOF
+            {
+                "ICD": {
+                    "api_version": "1.3.352",
+                    "library_arch": "${if arch == "x86_64" then "64" else "32"}",
+                    "library_path": "$out/lib/libvulkan_intel_hasvk13.so"
+                },
+                "file_format_version": "1.0.1"
+            }
+            EOF
+
+            if [ -f libRusticlOpenCL.so.1 ]; then
+              install -m 0755 libRusticlOpenCL.so.1 $out/lib/
+              mkdir -p $out/etc/OpenCL/vendors
+              echo $out/lib/libRusticlOpenCL.so.1 > $out/etc/OpenCL/vendors/rusticl-ivb.icd
+            fi
+            runHook postInstall
+          '';
+        };
+
+      withoutHasvk =
+        mesa:
+        pkgs.symlinkJoin {
+          name = "${mesa.name}-without-hasvk";
+          paths = [ mesa ];
+          postBuild = ''
+            rm -f $out/share/vulkan/icd.d/intel_hasvk_icd.*.json
+          '';
+        };
+
+      # pocl with the gen7 device (OpenCL on the HD 4000) and the host CPU
+      # device, from Drivers/pocl-gen7/release.sh. The gen7 device finds
+      # libgbe and beignet's library in lib/beignet next to itself.
+      pocl-gen7 = pkgs.stdenv.mkDerivation {
+        pname = "pocl-gen7";
+        version = "release";
+        src = ../../../drivers/pocl-gen7;
+
+        nativeBuildInputs = [ pkgs.autoPatchelfHook ];
+        buildInputs = with pkgs; [
+          libdrm
+          hwloc
+          zlib
+          zstd
+          libxml2
+          llvmPackages_21.llvm.lib
+          llvmPackages_21.clang-unwrapped.lib # libgbe: libclang-cpp
+          stdenv.cc.cc.lib
+        ];
+        dontStrip = true; # stripped by release.sh
+
+        installPhase = ''
+          runHook preInstall
+          mkdir -p $out/etc/OpenCL/vendors
+          cp -a lib share $out/
+          echo $out/lib/libpocl.so.2 > $out/etc/OpenCL/vendors/pocl-gen7.icd
+          runHook postInstall
+        '';
+      };
+    in
+    {
+      hardware.graphics = {
+        package = withoutHasvk pkgs.mesa;
+        package32 = withoutHasvk pkgs.pkgsi686Linux.mesa;
+        extraPackages = [
+          (drivers pkgs "x86_64")
+          pocl-gen7
+        ];
+        extraPackages32 = [ (drivers pkgs.pkgsi686Linux "i686") ];
+      };
+      # sessionVariables: set through PAM for the whole session, so every
+      # shell (nushell too) and every program started from it sees them
+      environment.sessionVariables = {
+        RUSTICL_ENABLE = "crocus";
+        # pocl builds basic and pthread (both the CPU); the GPU comes first
+        POCL_DEVICES = "gen7 pthread";
+      };
+    };
+}