| //===--- opencl-c.h - OpenCL C language builtin function header -----------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef _OPENCL_H_ |
| #define _OPENCL_H_ |
| |
| #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0 |
| #ifndef cl_khr_depth_images |
| #define cl_khr_depth_images |
| #endif //cl_khr_depth_images |
| #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0 |
| |
| #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 |
| |
| #define __ovld __attribute__((overloadable)) |
| #define __conv __attribute__((convergent)) |
| |
| // Optimizations |
| #define __purefn __attribute__((pure)) |
| #define __cnfn __attribute__((const)) |
| |
| // 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))); |
| 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))); |
| 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))); |
| 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_fp16 |
| #pragma OPENCL EXTENSION cl_khr_fp16 : enable |
| 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 |
| #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))); |
| 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 |
| |
| #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0 |
| #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/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); |
|
