| //===--- opencl-c.h - OpenCL C language builtin function header -----------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef _OPENCL_H_ |
| #define _OPENCL_H_ |
| |
| #include "opencl-c-base.h" |
| |
| #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) |
| #ifndef cl_khr_depth_images |
| #define cl_khr_depth_images |
| #endif //cl_khr_depth_images |
| #endif //defined(__OPENCL_CPP_VERSION__) || (__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 |
| |
| #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) |
| #pragma OPENCL EXTENSION cl_intel_planar_yuv : begin |
| #pragma OPENCL EXTENSION cl_intel_planar_yuv : end |
| #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) |
| |
| #define __ovld __attribute__((overloadable)) |
| #define __conv __attribute__((convergent)) |
| |
| // Optimizations |
| #define __purefn __attribute__((pure)) |
| #define __cnfn __attribute__((const)) |
| |
| |
| // OpenCL v1.1/1.2/2.0 s6.2.3 - Explicit conversions |
| |
| char __ovld __cnfn convert_char_rte(char); |
| char __ovld __cnfn convert_char_sat_rte(char); |
| char __ovld __cnfn convert_char_rtz(char); |
| char __ovld __cnfn convert_char_sat_rtz(char); |
| char __ovld __cnfn convert_char_rtp(char); |
| char __ovld __cnfn convert_char_sat_rtp(char); |
| char __ovld __cnfn convert_char_rtn(char); |
| char __ovld __cnfn convert_char_sat_rtn(char); |
| char __ovld __cnfn convert_char(char); |
| char __ovld __cnfn convert_char_sat(char); |
| char __ovld __cnfn convert_char_rte(uchar); |
| char __ovld __cnfn convert_char_sat_rte(uchar); |
| char __ovld __cnfn convert_char_rtz(uchar); |
| char __ovld __cnfn convert_char_sat_rtz(uchar); |
| char __ovld __cnfn convert_char_rtp(uchar); |
| char __ovld __cnfn convert_char_sat_rtp(uchar); |
| char __ovld __cnfn convert_char_rtn(uchar); |
| char __ovld __cnfn convert_char_sat_rtn(uchar); |
| char __ovld __cnfn convert_char(uchar); |
| char __ovld __cnfn convert_char_sat(uchar); |
| char __ovld __cnfn convert_char_rte(short); |
| char __ovld __cnfn convert_char_sat_rte(short); |
| char __ovld __cnfn convert_char_rtz(short); |
| char __ovld __cnfn convert_char_sat_rtz(short); |
| char __ovld __cnfn convert_char_rtp(short); |
| char __ovld __cnfn convert_char_sat_rtp(short); |
| char __ovld __cnfn convert_char_rtn(short); |
| char __ovld __cnfn convert_char_sat_rtn(short); |
| char __ovld __cnfn convert_char(short); |
| char __ovld __cnfn convert_char_sat(short); |
| char __ovld __cnfn convert_char_rte(ushort); |
| char __ovld __cnfn convert_char_sat_rte(ushort); |
| char __ovld __cnfn convert_char_rtz(ushort); |
| char __ovld __cnfn convert_char_sat_rtz(ushort); |
| char __ovld __cnfn convert_char_rtp(ushort); |
| char __ovld __cnfn convert_char_sat_rtp(ushort); |
| char __ovld __cnfn convert_char_rtn(ushort); |
| char __ovld __cnfn convert_char_sat_rtn(ushort); |
| char __ovld __cnfn convert_char(ushort); |
| char __ovld __cnfn convert_char_sat(ushort); |
| char __ovld __cnfn convert_char_rte(int); |
| char __ovld __cnfn convert_char_sat_rte(int); |
| char __ovld __cnfn convert_char_rtz(int); |
| char __ovld __cnfn convert_char_sat_rtz(int); |
| char __ovld __cnfn convert_char_rtp(int); |
| char __ovld __cnfn convert_char_sat_rtp(int); |
| char __ovld __cnfn convert_char_rtn(int); |
| char __ovld __cnfn convert_char_sat_rtn(int); |
| char __ovld __cnfn convert_char(int); |
| char __ovld __cnfn convert_char_sat(int); |
| char __ovld __cnfn convert_char_rte(uint); |
| char __ovld __cnfn convert_char_sat_rte(uint); |
| char __ovld __cnfn convert_char_rtz(uint); |
| char __ovld __cnfn convert_char_sat_rtz(uint); |
| char __ovld __cnfn convert_char_rtp(uint); |
| char __ovld __cnfn convert_char_sat_rtp(uint); |
| char __ovld __cnfn convert_char_rtn(uint); |
| char __ovld __cnfn convert_char_sat_rtn(uint); |
| char __ovld __cnfn convert_char(uint); |
| char __ovld __cnfn convert_char_sat(uint); |
| char __ovld __cnfn convert_char_rte(long); |
| char __ovld __cnfn convert_char_sat_rte(long); |
| char __ovld __cnfn convert_char_rtz(long); |
| char __ovld __cnfn convert_char_sat_rtz(long); |
| char __ovld __cnfn convert_char_rtp(long); |
| char __ovld __cnfn convert_char_sat_rtp(long); |
| char __ovld __cnfn convert_char_rtn(long); |
| char __ovld __cnfn convert_char_sat_rtn(long); |
| char __ovld __cnfn convert_char(long); |
| char __ovld __cnfn convert_char_sat(long); |
| char __ovld __cnfn convert_char_rte(ulong); |
| char __ovld __cnfn convert_char_sat_rte(ulong); |
| char __ovld __cnfn convert_char_rtz(ulong); |
| char __ovld __cnfn convert_char_sat_rtz(ulong); |
| char __ovld __cnfn convert_char_rtp(ulong); |
| char __ovld __cnfn convert_char_sat_rtp(ulong); |
| char __ovld __cnfn convert_char_rtn(ulong); |
| char __ovld __cnfn convert_char_sat_rtn(ulong); |
| char __ovld __cnfn convert_char(ulong); |
| char __ovld __cnfn convert_char_sat(ulong); |
| char __ovld __cnfn convert_char_rte(float); |
| char __ovld __cnfn convert_char_sat_rte(float); |
| char __ovld __cnfn convert_char_rtz(float); |
| char __ovld __cnfn convert_char_sat_rtz(float); |
| char __ovld __cnfn convert_char_rtp(float); |
| char __ovld __cnfn convert_char_sat_rtp(float); |
| char __ovld __cnfn convert_char_rtn(float); |
| char __ovld __cnfn convert_char_sat_rtn(float); |
| char __ovld __cnfn convert_char(float); |
| char __ovld __cnfn convert_char_sat(float); |
| uchar __ovld __cnfn convert_uchar_rte(char); |
| uchar __ovld __cnfn convert_uchar_sat_rte(char); |
| uchar __ovld __cnfn convert_uchar_rtz(char); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(char); |
| uchar __ovld __cnfn convert_uchar_rtp(char); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(char); |
| uchar __ovld __cnfn convert_uchar_rtn(char); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(char); |
| uchar __ovld __cnfn convert_uchar(char); |
| uchar __ovld __cnfn convert_uchar_sat(char); |
| uchar __ovld __cnfn convert_uchar_rte(uchar); |
| uchar __ovld __cnfn convert_uchar_sat_rte(uchar); |
| uchar __ovld __cnfn convert_uchar_rtz(uchar); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(uchar); |
| uchar __ovld __cnfn convert_uchar_rtp(uchar); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(uchar); |
| uchar __ovld __cnfn convert_uchar_rtn(uchar); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(uchar); |
| uchar __ovld __cnfn convert_uchar(uchar); |
| uchar __ovld __cnfn convert_uchar_sat(uchar); |
| uchar __ovld __cnfn convert_uchar_rte(short); |
| uchar __ovld __cnfn convert_uchar_sat_rte(short); |
| uchar __ovld __cnfn convert_uchar_rtz(short); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(short); |
| uchar __ovld __cnfn convert_uchar_rtp(short); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(short); |
| uchar __ovld __cnfn convert_uchar_rtn(short); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(short); |
| uchar __ovld __cnfn convert_uchar(short); |
| uchar __ovld __cnfn convert_uchar_sat(short); |
| uchar __ovld __cnfn convert_uchar_rte(ushort); |
| uchar __ovld __cnfn convert_uchar_sat_rte(ushort); |
| uchar __ovld __cnfn convert_uchar_rtz(ushort); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(ushort); |
| uchar __ovld __cnfn convert_uchar_rtp(ushort); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(ushort); |
| uchar __ovld __cnfn convert_uchar_rtn(ushort); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(ushort); |
| uchar __ovld __cnfn convert_uchar(ushort); |
| uchar __ovld __cnfn convert_uchar_sat(ushort); |
| uchar __ovld __cnfn convert_uchar_rte(int); |
| uchar __ovld __cnfn convert_uchar_sat_rte(int); |
| uchar __ovld __cnfn convert_uchar_rtz(int); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(int); |
| uchar __ovld __cnfn convert_uchar_rtp(int); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(int); |
| uchar __ovld __cnfn convert_uchar_rtn(int); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(int); |
| uchar __ovld __cnfn convert_uchar(int); |
| uchar __ovld __cnfn convert_uchar_sat(int); |
| uchar __ovld __cnfn convert_uchar_rte(uint); |
| uchar __ovld __cnfn convert_uchar_sat_rte(uint); |
| uchar __ovld __cnfn convert_uchar_rtz(uint); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(uint); |
| uchar __ovld __cnfn convert_uchar_rtp(uint); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(uint); |
| uchar __ovld __cnfn convert_uchar_rtn(uint); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(uint); |
| uchar __ovld __cnfn convert_uchar(uint); |
| uchar __ovld __cnfn convert_uchar_sat(uint); |
| uchar __ovld __cnfn convert_uchar_rte(long); |
| uchar __ovld __cnfn convert_uchar_sat_rte(long); |
| uchar __ovld __cnfn convert_uchar_rtz(long); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(long); |
| uchar __ovld __cnfn convert_uchar_rtp(long); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(long); |
| uchar __ovld __cnfn convert_uchar_rtn(long); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(long); |
| uchar __ovld __cnfn convert_uchar(long); |
| uchar __ovld __cnfn convert_uchar_sat(long); |
| uchar __ovld __cnfn convert_uchar_rte(ulong); |
| uchar __ovld __cnfn convert_uchar_sat_rte(ulong); |
| uchar __ovld __cnfn convert_uchar_rtz(ulong); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(ulong); |
| uchar __ovld __cnfn convert_uchar_rtp(ulong); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(ulong); |
| uchar __ovld __cnfn convert_uchar_rtn(ulong); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(ulong); |
| uchar __ovld __cnfn convert_uchar(ulong); |
| uchar __ovld __cnfn convert_uchar_sat(ulong); |
| uchar __ovld __cnfn convert_uchar_rte(float); |
| uchar __ovld __cnfn convert_uchar_sat_rte(float); |
| uchar __ovld __cnfn convert_uchar_rtz(float); |
| uchar __ovld __cnfn convert_uchar_sat_rtz(float); |
| uchar __ovld __cnfn convert_uchar_rtp(float); |
| uchar __ovld __cnfn convert_uchar_sat_rtp(float); |
| uchar __ovld __cnfn convert_uchar_rtn(float); |
| uchar __ovld __cnfn convert_uchar_sat_rtn(float); |
| uchar __ovld __cnfn convert_uchar(float); |
| uchar __ovld __cnfn convert_uchar_sat(float); |
| |
| short __ovld __cnfn convert_short_rte(char); |
| short __ovld __cnfn convert_short_sat_rte(char); |
| short __ovld __cnfn convert_short_rtz(char); |
| short __ovld __cnfn convert_short_sat_rtz(char); |
| short __ovld __cnfn convert_short_rtp(char); |
| short __ovld __cnfn convert_short_sat_rtp(char); |
| short __ovld __cnfn convert_short_rtn(char); |
| short __ovld __cnfn convert_short_sat_rtn(char); |
| short __ovld __cnfn convert_short(char); |
| short __ovld __cnfn convert_short_sat(char); |
| short __ovld __cnfn convert_short_rte(uchar); |
| short __ovld __cnfn convert_short_sat_rte(uchar); |
| short __ovld __cnfn convert_short_rtz(uchar); |
| short __ovld __cnfn convert_short_sat_rtz(uchar); |
| short __ovld __cnfn convert_short_rtp(uchar); |
| short __ovld __cnfn convert_short_sat_rtp(uchar); |
| short __ovld __cnfn convert_short_rtn(uchar); |
| short __ovld __cnfn convert_short_sat_rtn(uchar); |
| short __ovld __cnfn convert_short(uchar); |
| short __ovld __cnfn convert_short_sat(uchar); |
| short __ovld __cnfn convert_short_rte(short); |
| short __ovld __cnfn convert_short_sat_rte(short); |
| short __ovld __cnfn convert_short_rtz(short); |
| short __ovld __cnfn convert_short_sat_rtz(short); |
| short __ovld __cnfn convert_short_rtp(short); |
| short __ovld __cnfn convert_short_sat_rtp(short); |
| short __ovld __cnfn convert_short_rtn(short); |
| short __ovld __cnfn convert_short_sat_rtn(short); |
| short __ovld __cnfn convert_short(short); |
| short __ovld __cnfn convert_short_sat(short); |
| short __ovld __cnfn convert_short_rte(ushort); |
| short __ovld __cnfn convert_short_sat_rte(ushort); |
| short __ovld __cnfn convert_short_rtz(ushort); |
| short __ovld __cnfn convert_short_sat_rtz(ushort); |
| short __ovld __cnfn convert_short_rtp(ushort); |
| short __ovld __cnfn convert_short_sat_rtp(ushort); |
| short __ovld __cnfn convert_short_rtn(ushort); |
| short __ovld __cnfn convert_short_sat_rtn(ushort); |
| short __ovld __cnfn convert_short(ushort); |
| short __ovld __cnfn convert_short_sat(ushort); |
| short __ovld __cnfn convert_short_rte(int); |
| short __ovld __cnfn convert_short_sat_rte(int); |
| short __ovld __cnfn convert_short_rtz(int); |
| short __ovld __cnfn convert_short_sat_rtz(int); |
| short __ovld __cnfn convert_short_rtp(int); |
| short __ovld __cnfn convert_short_sat_rtp(int); |
| short __ovld __cnfn convert_short_rtn(int); |
| short __ovld __cnfn convert_short_sat_rtn(int); |
| short __ovld __cnfn convert_short(int); |
| short __ovld __cnfn convert_short_sat(int); |
| short __ovld __cnfn convert_short_rte(uint); |
| short __ovld __cnfn convert_short_sat_rte(uint); |
| short __ovld __cnfn convert_short_rtz(uint); |
| short __ovld __cnfn convert_short_sat_rtz(uint); |
| short __ovld __cnfn convert_short_rtp(uint); |
| short __ovld __cnfn convert_short_sat_rtp(uint); |
| short __ovld __cnfn convert_short_rtn(uint); |
| short __ovld __cnfn convert_short_sat_rtn(uint); |
| short __ovld __cnfn convert_short(uint); |
| short __ovld __cnfn convert_short_sat(uint); |
| short __ovld __cnfn convert_short_rte(long); |
| short __ovld __cnfn convert_short_sat_rte(long); |
| short __ovld __cnfn convert_short_rtz(long); |
| short __ovld __cnfn convert_short_sat_rtz(long); |
| short __ovld __cnfn convert_short_rtp(long); |
| short __ovld __cnfn convert_short_sat_rtp(long); |
| short __ovld __cnfn convert_short_rtn(long); |
| short __ovld __cnfn convert_short_sat_rtn(long); |
| short __ovld __cnfn convert_short(long); |
| short __ovld __cnfn convert_short_sat(long); |
| short __ovld __cnfn convert_short_rte(ulong); |
| short __ovld __cnfn convert_short_sat_rte(ulong); |
| short __ovld __cnfn convert_short_rtz(ulong); |
| short __ovld __cnfn convert_short_sat_rtz(ulong); |
| short __ovld __cnfn convert_short_rtp(ulong); |
| short __ovld __cnfn convert_short_sat_rtp(ulong); |
| short __ovld __cnfn convert_short_rtn(ulong); |
| short __ovld __cnfn convert_short_sat_rtn(ulong); |
| short __ovld __cnfn convert_short(ulong); |
| short __ovld __cnfn convert_short_sat(ulong); |
| short __ovld __cnfn convert_short_rte(float); |
| short __ovld __cnfn convert_short_sat_rte(float); |
| short __ovld __cnfn convert_short_rtz(float); |
| short __ovld __cnfn convert_short_sat_rtz(float); |
| short __ovld __cnfn convert_short_rtp(float); |
| short __ovld __cnfn convert_short_sat_rtp(float); |
| short __ovld __cnfn convert_short_rtn(float); |
| short __ovld __cnfn convert_short_sat_rtn(float); |
| short __ovld __cnfn convert_short(float); |
| short __ovld __cnfn convert_short_sat(float); |
| ushort __ovld __cnfn convert_ushort_rte(char); |
| ushort __ovld __cnfn convert_ushort_sat_rte(char); |
| ushort __ovld __cnfn convert_ushort_rtz(char); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(char); |
| ushort __ovld __cnfn convert_ushort_rtp(char); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(char); |
| ushort __ovld __cnfn convert_ushort_rtn(char); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(char); |
| ushort __ovld __cnfn convert_ushort(char); |
| ushort __ovld __cnfn convert_ushort_sat(char); |
| ushort __ovld __cnfn convert_ushort_rte(uchar); |
| ushort __ovld __cnfn convert_ushort_sat_rte(uchar); |
| ushort __ovld __cnfn convert_ushort_rtz(uchar); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(uchar); |
| ushort __ovld __cnfn convert_ushort_rtp(uchar); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(uchar); |
| ushort __ovld __cnfn convert_ushort_rtn(uchar); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(uchar); |
| ushort __ovld __cnfn convert_ushort(uchar); |
| ushort __ovld __cnfn convert_ushort_sat(uchar); |
| ushort __ovld __cnfn convert_ushort_rte(short); |
| ushort __ovld __cnfn convert_ushort_sat_rte(short); |
| ushort __ovld __cnfn convert_ushort_rtz(short); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(short); |
| ushort __ovld __cnfn convert_ushort_rtp(short); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(short); |
| ushort __ovld __cnfn convert_ushort_rtn(short); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(short); |
| ushort __ovld __cnfn convert_ushort(short); |
| ushort __ovld __cnfn convert_ushort_sat(short); |
| ushort __ovld __cnfn convert_ushort_rte(ushort); |
| ushort __ovld __cnfn convert_ushort_sat_rte(ushort); |
| ushort __ovld __cnfn convert_ushort_rtz(ushort); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(ushort); |
| ushort __ovld __cnfn convert_ushort_rtp(ushort); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(ushort); |
| ushort __ovld __cnfn convert_ushort_rtn(ushort); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(ushort); |
| ushort __ovld __cnfn convert_ushort(ushort); |
| ushort __ovld __cnfn convert_ushort_sat(ushort); |
| ushort __ovld __cnfn convert_ushort_rte(int); |
| ushort __ovld __cnfn convert_ushort_sat_rte(int); |
| ushort __ovld __cnfn convert_ushort_rtz(int); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(int); |
| ushort __ovld __cnfn convert_ushort_rtp(int); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(int); |
| ushort __ovld __cnfn convert_ushort_rtn(int); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(int); |
| ushort __ovld __cnfn convert_ushort(int); |
| ushort __ovld __cnfn convert_ushort_sat(int); |
| ushort __ovld __cnfn convert_ushort_rte(uint); |
| ushort __ovld __cnfn convert_ushort_sat_rte(uint); |
| ushort __ovld __cnfn convert_ushort_rtz(uint); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(uint); |
| ushort __ovld __cnfn convert_ushort_rtp(uint); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(uint); |
| ushort __ovld __cnfn convert_ushort_rtn(uint); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(uint); |
| ushort __ovld __cnfn convert_ushort(uint); |
| ushort __ovld __cnfn convert_ushort_sat(uint); |
| ushort __ovld __cnfn convert_ushort_rte(long); |
| ushort __ovld __cnfn convert_ushort_sat_rte(long); |
| ushort __ovld __cnfn convert_ushort_rtz(long); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(long); |
| ushort __ovld __cnfn convert_ushort_rtp(long); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(long); |
| ushort __ovld __cnfn convert_ushort_rtn(long); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(long); |
| ushort __ovld __cnfn convert_ushort(long); |
| ushort __ovld __cnfn convert_ushort_sat(long); |
| ushort __ovld __cnfn convert_ushort_rte(ulong); |
| ushort __ovld __cnfn convert_ushort_sat_rte(ulong); |
| ushort __ovld __cnfn convert_ushort_rtz(ulong); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(ulong); |
| ushort __ovld __cnfn convert_ushort_rtp(ulong); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(ulong); |
| ushort __ovld __cnfn convert_ushort_rtn(ulong); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(ulong); |
| ushort __ovld __cnfn convert_ushort(ulong); |
| ushort __ovld __cnfn convert_ushort_sat(ulong); |
| ushort __ovld __cnfn convert_ushort_rte(float); |
| ushort __ovld __cnfn convert_ushort_sat_rte(float); |
| ushort __ovld __cnfn convert_ushort_rtz(float); |
| ushort __ovld __cnfn convert_ushort_sat_rtz(float); |
| ushort __ovld __cnfn convert_ushort_rtp(float); |
| ushort __ovld __cnfn convert_ushort_sat_rtp(float); |
| ushort __ovld __cnfn convert_ushort_rtn(float); |
| ushort __ovld __cnfn convert_ushort_sat_rtn(float); |
| ushort __ovld __cnfn convert_ushort(float); |
| ushort __ovld __cnfn convert_ushort_sat(float); |
| int __ovld __cnfn convert_int_rte(char); |
| int __ovld __cnfn convert_int_sat_rte(char); |
| int __ovld __cnfn convert_int_rtz(char); |
| int __ovld __cnfn convert_int_sat_rtz(char); |
| int __ovld __cnfn convert_int_rtp(char); |
| int __ovld __cnfn convert_int_sat_rtp(char); |
| int __ovld __cnfn convert_int_rtn(char); |
| int __ovld __cnfn convert_int_sat_rtn(char); |
| int __ovld __cnfn convert_int(char); |
| int __ovld __cnfn convert_int_sat(char); |
| int __ovld __cnfn convert_int_rte(uchar); |
| int __ovld __cnfn convert_int_sat_rte(uchar); |
| int __ovld __cnfn convert_int_rtz(uchar); |
| int __ovld __cnfn convert_int_sat_rtz(uchar); |
| int __ovld __cnfn convert_int_rtp(uchar); |
| int __ovld __cnfn convert_int_sat_rtp(uchar); |
| int __ovld __cnfn convert_int_rtn(uchar); |
| int __ovld __cnfn convert_int_sat_rtn(uchar); |
| int __ovld __cnfn convert_int(uchar); |
| int __ovld __cnfn convert_int_sat(uchar); |
| int __ovld __cnfn convert_int_rte(short); |
| int __ovld __cnfn convert_int_sat_rte(short); |
| int __ovld __cnfn convert_int_rtz(short); |
| int __ovld __cnfn convert_int_sat_rtz(short); |
| int __ovld __cnfn convert_int_rtp(short); |
| int __ovld __cnfn convert_int_sat_rtp(short); |
| int __ovld __cnfn convert_int_rtn(short); |
| int __ovld __cnfn convert_int_sat_rtn(short); |
| int __ovld __cnfn convert_int(short); |
| int __ovld __cnfn convert_int_sat(short); |
| int __ovld __cnfn convert_int_rte(ushort); |
| int __ovld __cnfn convert_int_sat_rte(ushort); |
| int __ovld __cnfn convert_int_rtz(ushort); |
| int __ovld __cnfn convert_int_sat_rtz(ushort); |
| int __ovld __cnfn convert_int_rtp(ushort); |
| int __ovld __cnfn convert_int_sat_rtp(ushort); |
| int __ovld __cnfn convert_int_rtn(ushort); |
| int __ovld __cnfn convert_int_sat_rtn(ushort); |
| int __ovld __cnfn convert_int(ushort); |
| int __ovld __cnfn convert_int_sat(ushort); |
| int __ovld __cnfn convert_int_rte(int); |
| int __ovld __cnfn convert_int_sat_rte(int); |
| int __ovld __cnfn convert_int_rtz(int); |
| int __ovld __cnfn convert_int_sat_rtz(int); |
| int __ovld __cnfn convert_int_rtp(int); |
| int __ovld __cnfn convert_int_sat_rtp(int); |
| int __ovld __cnfn convert_int_rtn(int); |
| int __ovld __cnfn convert_int_sat_rtn(int); |
| int __ovld __cnfn convert_int(int); |
| int __ovld __cnfn convert_int_sat(int); |
| int __ovld __cnfn convert_int_rte(uint); |
| int __ovld __cnfn convert_int_sat_rte(uint); |
| int __ovld __cnfn convert_int_rtz(uint); |
| int __ovld __cnfn convert_int_sat_rtz(uint); |
| int __ovld __cnfn convert_int_rtp(uint); |
| int __ovld __cnfn convert_int_sat_rtp(uint); |
| int __ovld __cnfn convert_int_rtn(uint); |
| int __ovld __cnfn convert_int_sat_rtn(uint); |
| int __ovld __cnfn convert_int(uint); |
| int __ovld __cnfn convert_int_sat(uint); |
| int __ovld __cnfn convert_int_rte(long); |
| int __ovld __cnfn convert_int_sat_rte(long); |
| int __ovld __cnfn convert_int_rtz(long); |
| int __ovld __cnfn convert_int_sat_rtz(long); |
| int __ovld __cnfn convert_int_rtp(long); |
| int __ovld __cnfn convert_int_sat_rtp(long); |
| int __ovld __cnfn convert_int_rtn(long); |
| int __ovld __cnfn convert_int_sat_rtn(long); |
| int __ovld __cnfn convert_int(long); |
| int __ovld __cnfn convert_int_sat(long); |
| int __ovld __cnfn convert_int_rte(ulong); |
| int __ovld __cnfn convert_int_sat_rte(ulong); |
| int __ovld __cnfn convert_int_rtz(ulong); |
| int __ovld __cnfn convert_int_sat_rtz(ulong); |
| int __ovld __cnfn convert_int_rtp(ulong); |
| int __ovld __cnfn convert_int_sat_rtp(ulong); |
| int __ovld __cnfn convert_int_rtn(ulong); |
| int __ovld __cnfn convert_int_sat_rtn(ulong); |
| int __ovld __cnfn convert_int(ulong); |
| int __ovld __cnfn convert_int_sat(ulong); |
| int __ovld __cnfn convert_int_rte(float); |
| int __ovld __cnfn convert_int_sat_rte(float); |
| int __ovld __cnfn convert_int_rtz(float); |
| int __ovld __cnfn convert_int_sat_rtz(float); |
| int __ovld __cnfn convert_int_rtp(float); |
| int __ovld __cnfn convert_int_sat_rtp(float); |
| int __ovld __cnfn convert_int_rtn(float); |
| int __ovld __cnfn convert_int_sat_rtn(float); |
| int __ovld __cnfn convert_int(float); |
| int __ovld __cnfn convert_int_sat(float); |
| uint __ovld __cnfn convert_uint_rte(char); |
| uint __ovld __cnfn convert_uint_sat_rte(char); |
| uint __ovld __cnfn convert_uint_rtz(char); |
| uint __ovld __cnfn convert_uint_sat_rtz(char); |
| uint __ovld __cnfn convert_uint_rtp(char); |
| uint __ovld __cnfn convert_uint_sat_rtp(char); |
| uint __ovld __cnfn convert_uint_rtn(char); |
| uint __ovld __cnfn convert_uint_sat_rtn(char); |
| uint __ovld __cnfn convert_uint(char); |
| uint __ovld __cnfn convert_uint_sat(char); |
| uint __ovld __cnfn convert_uint_rte(uchar); |
| uint __ovld __cnfn convert_uint_sat_rte(uchar); |
| uint __ovld __cnfn convert_uint_rtz(uchar); |
| uint __ovld __cnfn convert_uint_sat_rtz(uchar); |
| uint __ovld __cnfn convert_uint_rtp(uchar); |
| uint __ovld __cnfn convert_uint_sat_rtp(uchar); |
| uint __ovld __cnfn convert_uint_rtn(uchar); |
| uint __ovld __cnfn convert_uint_sat_rtn(uchar); |
| uint __ovld __cnfn convert_uint(uchar); |
| uint __ovld __cnfn convert_uint_sat(uchar); |
| uint __ovld __cnfn convert_uint_rte(short); |
| uint __ovld __cnfn convert_uint_sat_rte(short); |
| uint __ovld __cnfn convert_uint_rtz(short); |
| uint __ovld __cnfn convert_uint_sat_rtz(short); |
| uint __ovld __cnfn convert_uint_rtp(short); |
| uint __ovld __cnfn convert_uint_sat_rtp(short); |
| uint __ovld __cnfn convert_uint_rtn(short); |
| uint __ovld __cnfn convert_uint_sat_rtn(short); |
| uint __ovld __cnfn convert_uint(short); |
| uint __ovld __cnfn convert_uint_sat(short); |
| uint __ovld __cnfn convert_uint_rte(ushort); |
| uint __ovld __cnfn convert_uint_sat_rte(ushort); |
| uint __ovld __cnfn convert_uint_rtz(ushort); |
| uint __ovld __cnfn convert_uint_sat_rtz(ushort); |
| uint __ovld __cnfn convert_uint_rtp(ushort); |
| uint __ovld __cnfn convert_uint_sat_rtp(ushort); |
| uint __ovld __cnfn convert_uint_rtn(ushort); |
| uint __ovld __cnfn convert_uint_sat_rtn(ushort); |
| uint __ovld __cnfn convert_uint(ushort); |
| uint __ovld __cnfn convert_uint_sat(ushort); |
| uint __ovld __cnfn convert_uint_rte(int); |
| uint __ovld __cnfn convert_uint_sat_rte(int); |
| uint __ovld __cnfn convert_uint_rtz(int); |
| uint __ovld __cnfn convert_uint_sat_rtz(int); |
| uint __ovld __cnfn convert_uint_rtp(int); |
| uint __ovld __cnfn convert_uint_sat_rtp(int); |
| uint __ovld __cnfn convert_uint_rtn(int); |
| uint __ovld __cnfn convert_uint_sat_rtn(int); |
| uint __ovld __cnfn convert_uint(int); |
| uint __ovld __cnfn convert_uint_sat(int); |
| uint __ovld __cnfn convert_uint_rte(uint); |
| uint __ovld __cnfn convert_uint_sat_rte(uint); |
| uint __ovld __cnfn convert_uint_rtz(uint); |
| uint __ovld __cnfn convert_uint_sat_rtz(uint); |
| uint __ovld __cnfn convert_uint_rtp(uint); |
| uint __ovld __cnfn convert_uint_sat_rtp(uint); |
| uint __ovld __cnfn convert_uint_rtn(uint); |
| uint __ovld __cnfn convert_uint_sat_rtn(uint); |
| uint __ovld __cnfn convert_uint(uint); |
| uint __ovld __cnfn convert_uint_sat(uint); |
| uint __ovld __cnfn convert_uint_rte(long); |
| uint __ovld __cnfn convert_uint_sat_rte(long); |
| uint __ovld __cnfn convert_uint_rtz(long); |
| uint __ovld __cnfn convert_uint_sat_rtz(long); |
| uint __ovld __cnfn convert_uint_rtp(long); |
| uint __ovld __cnfn convert_uint_sat_rtp(long); |
| uint __ovld __cnfn convert_uint_rtn(long); |
| uint __ovld __cnfn convert_uint_sat_rtn(long); |
| uint __ovld __cnfn convert_uint(long); |
| uint __ovld __cnfn convert_uint_sat(long); |
| uint __ovld __cnfn convert_uint_rte(ulong); |
| uint __ovld __cnfn convert_uint_sat_rte(ulong); |
| uint __ovld __cnfn convert_uint_rtz(ulong); |
| uint __ovld __cnfn convert_uint_sat_rtz(ulong); |
| uint __ovld __cnfn convert_uint_rtp(ulong); |
| uint __ovld __cnfn convert_uint_sat_rtp(ulong); |
| uint __ovld __cnfn convert_uint_rtn(ulong); |
| uint __ovld __cnfn convert_uint_sat_rtn(ulong); |
| uint __ovld __cnfn convert_uint(ulong); |
| uint __ovld __cnfn convert_uint_sat(ulong); |
| uint __ovld __cnfn convert_uint_rte(float); |
| uint __ovld __cnfn convert_uint_sat_rte(float); |
| uint __ovld __cnfn convert_uint_rtz(float); |
| uint __ovld __cnfn convert_uint_sat_rtz(float); |
| uint __ovld __cnfn convert_uint_rtp(float); |
| uint __ovld __cnfn convert_uint_sat_rtp(float); |
| uint __ovld __cnfn convert_uint_rtn(float); |
| uint __ovld __cnfn convert_uint_sat_rtn(float); |
| uint __ovld __cnfn convert_uint(float); |
| uint __ovld __cnfn convert_uint_sat(float); |
| long __ovld __cnfn convert_long_rte(char); |
| long __ovld __cnfn convert_long_sat_rte(char); |
| long __ovld __cnfn convert_long_rtz(char); |
| long __ovld __cnfn convert_long_sat_rtz(char); |
| long __ovld __cnfn convert_long_rtp(char); |
| long __ovld __cnfn convert_long_sat_rtp(char); |
| long __ovld __cnfn convert_long_rtn(char); |
| long __ovld __cnfn convert_long_sat_rtn(char); |
| long __ovld __cnfn convert_long(char); |
| long __ovld __cnfn convert_long_sat(char); |
| long __ovld __cnfn convert_long_rte(uchar); |
| long __ovld __cnfn convert_long_sat_rte(uchar); |
| long __ovld __cnfn convert_long_rtz(uchar); |
| long __ovld __cnfn convert_long_sat_rtz(uchar); |
| long __ovld __cnfn convert_long_rtp(uchar); |
| long __ovld __cnfn convert_long_sat_rtp(uchar); |
| long __ovld __cnfn convert_long_rtn(uchar); |
| long __ovld __cnfn convert_long_sat_rtn(uchar); |
| long __ovld __cnfn convert_long(uchar); |
| long __ovld __cnfn convert_long_sat(uchar); |
| long __ovld __cnfn convert_long_rte(short); |
| long __ovld __cnfn convert_long_sat_rte(short); |
| long __ovld __cnfn convert_long_rtz(short); |
| long __ovld __cnfn convert_long_sat_rtz(short); |
| long __ovld __cnfn convert_long_rtp(short); |
| long __ovld __cnfn convert_long_sat_rtp(short); |
| long __ovld __cnfn convert_long_rtn(short); |
| long __ovld __cnfn convert_long_sat_rtn(short); |
| long __ovld __cnfn convert_long(short); |
| long __ovld __cnfn convert_long_sat(short); |
| long __ovld __cnfn convert_long_rte(ushort); |
| long __ovld __cnfn convert_long_sat_rte(ushort); |
| long __ovld __cnfn convert_long_rtz(ushort); |
| long __ovld __cnfn convert_long_sat_rtz(ushort); |
| long __ovld __cnfn convert_long_rtp(ushort); |
| long __ovld __cnfn convert_long_sat_rtp(ushort); |
| long __ovld __cnfn convert_long_rtn(ushort); |
| long __ovld __cnfn convert_long_sat_rtn(ushort); |
| long __ovld __cnfn convert_long(ushort); |
| long __ovld __cnfn convert_long_sat(ushort); |
| long __ovld __cnfn convert_long_rte(int); |
| long __ovld __cnfn convert_long_sat_rte(int); |
| long __ovld __cnfn convert_long_rtz(int); |
| long __ovld __cnfn convert_long_sat_rtz(int); |
| long __ovld __cnfn convert_long_rtp(int); |
| long __ovld __cnfn convert_long_sat_rtp(int); |
| long __ovld __cnfn convert_long_rtn(int); |
| long __ovld __cnfn convert_long_sat_rtn(int); |
| long __ovld __cnfn convert_long(int); |
| long __ovld __cnfn convert_long_sat(int); |
| long __ovld __cnfn convert_long_rte(uint); |
| long __ovld __cnfn convert_long_sat_rte(uint); |
| long __ovld __cnfn convert_long_rtz(uint); |
| long __ovld __cnfn convert_long_sat_rtz(uint); |
| long __ovld __cnfn convert_long_rtp(uint); |
| long __ovld __cnfn convert_long_sat_rtp(uint); |
| long __ovld __cnfn convert_long_rtn(uint); |
| long __ovld __cnfn convert_long_sat_rtn(uint); |
| long __ovld __cnfn convert_long(uint); |
| long __ovld __cnfn convert_long_sat(uint); |
| long __ovld __cnfn convert_long_rte(long); |
| long __ovld __cnfn convert_long_sat_rte(long); |
| long __ovld __cnfn convert_long_rtz(long); |
| long __ovld __cnfn convert_long_sat_rtz(long); |
| long __ovld __cnfn convert_long_rtp(long); |
| long __ovld __cnfn convert_long_sat_rtp(long); |
| long __ovld __cnfn convert_long_rtn(long); |
| long __ovld __cnfn convert_long_sat_rtn(long); |
| long __ovld __cnfn convert_long(long); |
| long __ovld __cnfn convert_long_sat(long); |
| long __ovld __cnfn convert_long_rte(ulong); |
| long __ovld __cnfn convert_long_sat_rte(ulong); |
| long __ovld __cnfn convert_long_rtz(ulong); |
| long __ovld __cnfn convert_long_sat_rtz(ulong); |
| long __ovld __cnfn convert_long_rtp(ulong); |
| long __ovld __cnfn convert_long_sat_rtp(ulong); |
| long __ovld __cnfn convert_long_rtn(ulong); |
| long __ovld __cnfn convert_long_sat_rtn(ulong); |
| long __ovld __cnfn convert_long(ulong); |
| long __ovld __cnfn convert_long_sat(ulong); |
| long __ovld __cnfn convert_long_rte(float); |
| long __ovld __cnfn convert_long_sat_rte(float); |
| long __ovld __cnfn convert_long_rtz(float); |
| long __ovld __cnfn convert_long_sat_rtz(float); |
| long __ovld __cnfn convert_long_rtp(float); |
| long __ovld __cnfn convert_long_sat_rtp(float); |
| long __ovld __cnfn convert_long_rtn(float); |
| long __ovld __cnfn convert_long_sat_rtn(float); |
| long __ovld __cnfn convert_long(float); |
| long __ovld __cnfn convert_long_sat(float); |
| ulong __ovld __cnfn convert_ulong_rte(char); |
| ulong __ovld __cnfn convert_ulong_sat_rte(char); |
| ulong __ovld __cnfn convert_ulong_rtz(char); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(char); |
| ulong __ovld __cnfn convert_ulong_rtp(char); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(char); |
| ulong __ovld __cnfn convert_ulong_rtn(char); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(char); |
| ulong __ovld __cnfn convert_ulong(char); |
| ulong __ovld __cnfn convert_ulong_sat(char); |
| ulong __ovld __cnfn convert_ulong_rte(uchar); |
| ulong __ovld __cnfn convert_ulong_sat_rte(uchar); |
| ulong __ovld __cnfn convert_ulong_rtz(uchar); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(uchar); |
| ulong __ovld __cnfn convert_ulong_rtp(uchar); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(uchar); |
| ulong __ovld __cnfn convert_ulong_rtn(uchar); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(uchar); |
| ulong __ovld __cnfn convert_ulong(uchar); |
| ulong __ovld __cnfn convert_ulong_sat(uchar); |
| ulong __ovld __cnfn convert_ulong_rte(short); |
| ulong __ovld __cnfn convert_ulong_sat_rte(short); |
| ulong __ovld __cnfn convert_ulong_rtz(short); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(short); |
| ulong __ovld __cnfn convert_ulong_rtp(short); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(short); |
| ulong __ovld __cnfn convert_ulong_rtn(short); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(short); |
| ulong __ovld __cnfn convert_ulong(short); |
| ulong __ovld __cnfn convert_ulong_sat(short); |
| ulong __ovld __cnfn convert_ulong_rte(ushort); |
| ulong __ovld __cnfn convert_ulong_sat_rte(ushort); |
| ulong __ovld __cnfn convert_ulong_rtz(ushort); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(ushort); |
| ulong __ovld __cnfn convert_ulong_rtp(ushort); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(ushort); |
| ulong __ovld __cnfn convert_ulong_rtn(ushort); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(ushort); |
| ulong __ovld __cnfn convert_ulong(ushort); |
| ulong __ovld __cnfn convert_ulong_sat(ushort); |
| ulong __ovld __cnfn convert_ulong_rte(int); |
| ulong __ovld __cnfn convert_ulong_sat_rte(int); |
| ulong __ovld __cnfn convert_ulong_rtz(int); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(int); |
| ulong __ovld __cnfn convert_ulong_rtp(int); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(int); |
| ulong __ovld __cnfn convert_ulong_rtn(int); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(int); |
| ulong __ovld __cnfn convert_ulong(int); |
| ulong __ovld __cnfn convert_ulong_sat(int); |
| ulong __ovld __cnfn convert_ulong_rte(uint); |
| ulong __ovld __cnfn convert_ulong_sat_rte(uint); |
| ulong __ovld __cnfn convert_ulong_rtz(uint); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(uint); |
| ulong __ovld __cnfn convert_ulong_rtp(uint); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(uint); |
| ulong __ovld __cnfn convert_ulong_rtn(uint); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(uint); |
| ulong __ovld __cnfn convert_ulong(uint); |
| ulong __ovld __cnfn convert_ulong_sat(uint); |
| ulong __ovld __cnfn convert_ulong_rte(long); |
| ulong __ovld __cnfn convert_ulong_sat_rte(long); |
| ulong __ovld __cnfn convert_ulong_rtz(long); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(long); |
| ulong __ovld __cnfn convert_ulong_rtp(long); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(long); |
| ulong __ovld __cnfn convert_ulong_rtn(long); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(long); |
| ulong __ovld __cnfn convert_ulong(long); |
| ulong __ovld __cnfn convert_ulong_sat(long); |
| ulong __ovld __cnfn convert_ulong_rte(ulong); |
| ulong __ovld __cnfn convert_ulong_sat_rte(ulong); |
| ulong __ovld __cnfn convert_ulong_rtz(ulong); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(ulong); |
| ulong __ovld __cnfn convert_ulong_rtp(ulong); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(ulong); |
| ulong __ovld __cnfn convert_ulong_rtn(ulong); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(ulong); |
| ulong __ovld __cnfn convert_ulong(ulong); |
| ulong __ovld __cnfn convert_ulong_sat(ulong); |
| ulong __ovld __cnfn convert_ulong_rte(float); |
| ulong __ovld __cnfn convert_ulong_sat_rte(float); |
| ulong __ovld __cnfn convert_ulong_rtz(float); |
| ulong __ovld __cnfn convert_ulong_sat_rtz(float); |
| ulong __ovld __cnfn convert_ulong_rtp(float); |
| ulong __ovld __cnfn convert_ulong_sat_rtp(float); |
| ulong __ovld __cnfn convert_ulong_rtn(float); |
| ulong __ovld __cnfn convert_ulong_sat_rtn(float); |
| ulong __ovld __cnfn convert_ulong(float); |
| ulong __ovld __cnfn convert_ulong_sat(float); |
| float __ovld __cnfn convert_float_rte(char); |
| float __ovld __cnfn convert_float_rtz(char); |
| float __ovld __cnfn convert_float_rtp(char); |
| float __ovld __cnfn convert_float_rtn(char); |
| float __ovld __cnfn convert_float(char); |
| float __ovld __cnfn convert_float_rte(uchar); |
| float __ovld __cnfn convert_float_rtz(uchar); |
| float __ovld __cnfn convert_float_rtp(uchar); |
| float __ovld __cnfn convert_float_rtn(uchar); |
| float __ovld __cnfn convert_float(uchar); |
| float __ovld __cnfn convert_float_rte(short); |
| float __ovld __cnfn convert_float_rtz(short); |
| float __ovld __cnfn convert_float_rtp(short); |
| float __ovld __cnfn convert_float_rtn(short); |
| float __ovld __cnfn convert_float(short); |
| float __ovld __cnfn convert_float_rte(ushort); |
| float __ovld __cnfn convert_float_rtz(ushort); |
| float __ovld __cnfn convert_float_rtp(ushort); |
| float __ovld __cnfn convert_float_rtn(ushort); |
| float __ovld __cnfn convert_float(ushort); |
| float __ovld __cnfn convert_float_rte(int); |
| float __ovld __cnfn convert_float_rtz(int); |
| float __ovld __cnfn convert_float_rtp(int); |
| float __ovld __cnfn convert_float_rtn(int); |
| float __ovld __cnfn convert_float(int); |
| float __ovld __cnfn convert_float_rte(uint); |
| float __ovld __cnfn convert_float_rtz(uint); |
| float __ovld __cnfn convert_float_rtp(uint); |
| float __ovld __cnfn convert_float_rtn(uint); |
| float __ovld __cnfn convert_float(uint); |
| float __ovld __cnfn convert_float_rte(long); |
| float __ovld __cnfn convert_float_rtz(long); |
| float __ovld __cnfn convert_float_rtp(long); |
| float __ovld __cnfn convert_float_rtn(long); |
| float __ovld __cnfn convert_float(long); |
| float __ovld __cnfn convert_float_rte(ulong); |
| float __ovld __cnfn convert_float_rtz(ulong); |
| float __ovld __cnfn convert_float_rtp(ulong); |
| float __ovld __cnfn convert_float_rtn(ulong); |
| float __ovld __cnfn convert_float(ulong); |
| float __ovld __cnfn convert_float_rte(float); |
| float __ovld __cnfn convert_float_rtz(float); |
| float __ovld __cnfn convert_float_rtp(float); |
| float __ovld __cnfn convert_float_rtn(float); |
| float __ovld __cnfn convert_float(float); |
| char2 __ovld __cnfn convert_char2_rte(char2); |
| char2 __ovld __cnfn convert_char2_sat_rte(char2); |
| char2 __ovld __cnfn convert_char2_rtz(char2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(char2); |
| char2 __ovld __cnfn convert_char2_rtp(char2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(char2); |
| char2 __ovld __cnfn convert_char2_rtn(char2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(char2); |
| char2 __ovld __cnfn convert_char2(char2); |
| char2 __ovld __cnfn convert_char2_sat(char2); |
| char2 __ovld __cnfn convert_char2_rte(uchar2); |
| char2 __ovld __cnfn convert_char2_sat_rte(uchar2); |
| char2 __ovld __cnfn convert_char2_rtz(uchar2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(uchar2); |
| char2 __ovld __cnfn convert_char2_rtp(uchar2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(uchar2); |
| char2 __ovld __cnfn convert_char2_rtn(uchar2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(uchar2); |
| char2 __ovld __cnfn convert_char2(uchar2); |
| char2 __ovld __cnfn convert_char2_sat(uchar2); |
| char2 __ovld __cnfn convert_char2_rte(short2); |
| char2 __ovld __cnfn convert_char2_sat_rte(short2); |
| char2 __ovld __cnfn convert_char2_rtz(short2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(short2); |
| char2 __ovld __cnfn convert_char2_rtp(short2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(short2); |
| char2 __ovld __cnfn convert_char2_rtn(short2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(short2); |
| char2 __ovld __cnfn convert_char2(short2); |
| char2 __ovld __cnfn convert_char2_sat(short2); |
| char2 __ovld __cnfn convert_char2_rte(ushort2); |
| char2 __ovld __cnfn convert_char2_sat_rte(ushort2); |
| char2 __ovld __cnfn convert_char2_rtz(ushort2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(ushort2); |
| char2 __ovld __cnfn convert_char2_rtp(ushort2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(ushort2); |
| char2 __ovld __cnfn convert_char2_rtn(ushort2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(ushort2); |
| char2 __ovld __cnfn convert_char2(ushort2); |
| char2 __ovld __cnfn convert_char2_sat(ushort2); |
| char2 __ovld __cnfn convert_char2_rte(int2); |
| char2 __ovld __cnfn convert_char2_sat_rte(int2); |
| char2 __ovld __cnfn convert_char2_rtz(int2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(int2); |
| char2 __ovld __cnfn convert_char2_rtp(int2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(int2); |
| char2 __ovld __cnfn convert_char2_rtn(int2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(int2); |
| char2 __ovld __cnfn convert_char2(int2); |
| char2 __ovld __cnfn convert_char2_sat(int2); |
| char2 __ovld __cnfn convert_char2_rte(uint2); |
| char2 __ovld __cnfn convert_char2_sat_rte(uint2); |
| char2 __ovld __cnfn convert_char2_rtz(uint2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(uint2); |
| char2 __ovld __cnfn convert_char2_rtp(uint2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(uint2); |
| char2 __ovld __cnfn convert_char2_rtn(uint2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(uint2); |
| char2 __ovld __cnfn convert_char2(uint2); |
| char2 __ovld __cnfn convert_char2_sat(uint2); |
| char2 __ovld __cnfn convert_char2_rte(long2); |
| char2 __ovld __cnfn convert_char2_sat_rte(long2); |
| char2 __ovld __cnfn convert_char2_rtz(long2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(long2); |
| char2 __ovld __cnfn convert_char2_rtp(long2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(long2); |
| char2 __ovld __cnfn convert_char2_rtn(long2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(long2); |
| char2 __ovld __cnfn convert_char2(long2); |
| char2 __ovld __cnfn convert_char2_sat(long2); |
| char2 __ovld __cnfn convert_char2_rte(ulong2); |
| char2 __ovld __cnfn convert_char2_sat_rte(ulong2); |
| char2 __ovld __cnfn convert_char2_rtz(ulong2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(ulong2); |
| char2 __ovld __cnfn convert_char2_rtp(ulong2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(ulong2); |
| char2 __ovld __cnfn convert_char2_rtn(ulong2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(ulong2); |
| char2 __ovld __cnfn convert_char2(ulong2); |
| char2 __ovld __cnfn convert_char2_sat(ulong2); |
| char2 __ovld __cnfn convert_char2_rte(float2); |
| char2 __ovld __cnfn convert_char2_sat_rte(float2); |
| char2 __ovld __cnfn convert_char2_rtz(float2); |
| char2 __ovld __cnfn convert_char2_sat_rtz(float2); |
| char2 __ovld __cnfn convert_char2_rtp(float2); |
| char2 __ovld __cnfn convert_char2_sat_rtp(float2); |
| char2 __ovld __cnfn convert_char2_rtn(float2); |
| char2 __ovld __cnfn convert_char2_sat_rtn(float2); |
| char2 __ovld __cnfn convert_char2(float2); |
| char2 __ovld __cnfn convert_char2_sat(float2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(char2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(char2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(char2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(char2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(char2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(char2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(char2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(char2); |
| uchar2 __ovld __cnfn convert_uchar2(char2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(char2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(uchar2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(short2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(short2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(short2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(short2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(short2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(short2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(short2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(short2); |
| uchar2 __ovld __cnfn convert_uchar2(short2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(short2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(ushort2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(int2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(int2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(int2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(int2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(int2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(int2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(int2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(int2); |
| uchar2 __ovld __cnfn convert_uchar2(int2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(int2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(uint2); |
| uchar2 __ovld __cnfn convert_uchar2(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(uint2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(long2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(long2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(long2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(long2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(long2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(long2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(long2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(long2); |
| uchar2 __ovld __cnfn convert_uchar2(long2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(long2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(ulong2); |
| uchar2 __ovld __cnfn convert_uchar2_rte(float2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rte(float2); |
| uchar2 __ovld __cnfn convert_uchar2_rtz(float2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtz(float2); |
| uchar2 __ovld __cnfn convert_uchar2_rtp(float2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtp(float2); |
| uchar2 __ovld __cnfn convert_uchar2_rtn(float2); |
| uchar2 __ovld __cnfn convert_uchar2_sat_rtn(float2); |
| uchar2 __ovld __cnfn convert_uchar2(float2); |
| uchar2 __ovld __cnfn convert_uchar2_sat(float2); |
| short2 __ovld __cnfn convert_short2_rte(char2); |
| short2 __ovld __cnfn convert_short2_sat_rte(char2); |
| short2 __ovld __cnfn convert_short2_rtz(char2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(char2); |
| short2 __ovld __cnfn convert_short2_rtp(char2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(char2); |
| short2 __ovld __cnfn convert_short2_rtn(char2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(char2); |
| short2 __ovld __cnfn convert_short2(char2); |
| short2 __ovld __cnfn convert_short2_sat(char2); |
| short2 __ovld __cnfn convert_short2_rte(uchar2); |
| short2 __ovld __cnfn convert_short2_sat_rte(uchar2); |
| short2 __ovld __cnfn convert_short2_rtz(uchar2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(uchar2); |
| short2 __ovld __cnfn convert_short2_rtp(uchar2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(uchar2); |
| short2 __ovld __cnfn convert_short2_rtn(uchar2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(uchar2); |
| short2 __ovld __cnfn convert_short2(uchar2); |
| short2 __ovld __cnfn convert_short2_sat(uchar2); |
| short2 __ovld __cnfn convert_short2_rte(short2); |
| short2 __ovld __cnfn convert_short2_sat_rte(short2); |
| short2 __ovld __cnfn convert_short2_rtz(short2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(short2); |
| short2 __ovld __cnfn convert_short2_rtp(short2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(short2); |
| short2 __ovld __cnfn convert_short2_rtn(short2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(short2); |
| short2 __ovld __cnfn convert_short2(short2); |
| short2 __ovld __cnfn convert_short2_sat(short2); |
| short2 __ovld __cnfn convert_short2_rte(ushort2); |
| short2 __ovld __cnfn convert_short2_sat_rte(ushort2); |
| short2 __ovld __cnfn convert_short2_rtz(ushort2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(ushort2); |
| short2 __ovld __cnfn convert_short2_rtp(ushort2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(ushort2); |
| short2 __ovld __cnfn convert_short2_rtn(ushort2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(ushort2); |
| short2 __ovld __cnfn convert_short2(ushort2); |
| short2 __ovld __cnfn convert_short2_sat(ushort2); |
| short2 __ovld __cnfn convert_short2_rte(int2); |
| short2 __ovld __cnfn convert_short2_sat_rte(int2); |
| short2 __ovld __cnfn convert_short2_rtz(int2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(int2); |
| short2 __ovld __cnfn convert_short2_rtp(int2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(int2); |
| short2 __ovld __cnfn convert_short2_rtn(int2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(int2); |
| short2 __ovld __cnfn convert_short2(int2); |
| short2 __ovld __cnfn convert_short2_sat(int2); |
| short2 __ovld __cnfn convert_short2_rte(uint2); |
| short2 __ovld __cnfn convert_short2_sat_rte(uint2); |
| short2 __ovld __cnfn convert_short2_rtz(uint2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(uint2); |
| short2 __ovld __cnfn convert_short2_rtp(uint2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(uint2); |
| short2 __ovld __cnfn convert_short2_rtn(uint2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(uint2); |
| short2 __ovld __cnfn convert_short2(uint2); |
| short2 __ovld __cnfn convert_short2_sat(uint2); |
| short2 __ovld __cnfn convert_short2_rte(long2); |
| short2 __ovld __cnfn convert_short2_sat_rte(long2); |
| short2 __ovld __cnfn convert_short2_rtz(long2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(long2); |
| short2 __ovld __cnfn convert_short2_rtp(long2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(long2); |
| short2 __ovld __cnfn convert_short2_rtn(long2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(long2); |
| short2 __ovld __cnfn convert_short2(long2); |
| short2 __ovld __cnfn convert_short2_sat(long2); |
| short2 __ovld __cnfn convert_short2_rte(ulong2); |
| short2 __ovld __cnfn convert_short2_sat_rte(ulong2); |
| short2 __ovld __cnfn convert_short2_rtz(ulong2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(ulong2); |
| short2 __ovld __cnfn convert_short2_rtp(ulong2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(ulong2); |
| short2 __ovld __cnfn convert_short2_rtn(ulong2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(ulong2); |
| short2 __ovld __cnfn convert_short2(ulong2); |
| short2 __ovld __cnfn convert_short2_sat(ulong2); |
| short2 __ovld __cnfn convert_short2_rte(float2); |
| short2 __ovld __cnfn convert_short2_sat_rte(float2); |
| short2 __ovld __cnfn convert_short2_rtz(float2); |
| short2 __ovld __cnfn convert_short2_sat_rtz(float2); |
| short2 __ovld __cnfn convert_short2_rtp(float2); |
| short2 __ovld __cnfn convert_short2_sat_rtp(float2); |
| short2 __ovld __cnfn convert_short2_rtn(float2); |
| short2 __ovld __cnfn convert_short2_sat_rtn(float2); |
| short2 __ovld __cnfn convert_short2(float2); |
| short2 __ovld __cnfn convert_short2_sat(float2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(char2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(char2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(char2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(char2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(char2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(char2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(char2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(char2); |
| ushort2 __ovld __cnfn convert_ushort2(char2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(char2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(uchar2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(short2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(short2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(short2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(short2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(short2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(short2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(short2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(short2); |
| ushort2 __ovld __cnfn convert_ushort2(short2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(short2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(ushort2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(int2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(int2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(int2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(int2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(int2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(int2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(int2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(int2); |
| ushort2 __ovld __cnfn convert_ushort2(int2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(int2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(uint2); |
| ushort2 __ovld __cnfn convert_ushort2(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(uint2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(long2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(long2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(long2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(long2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(long2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(long2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(long2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(long2); |
| ushort2 __ovld __cnfn convert_ushort2(long2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(long2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(ulong2); |
| ushort2 __ovld __cnfn convert_ushort2_rte(float2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rte(float2); |
| ushort2 __ovld __cnfn convert_ushort2_rtz(float2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtz(float2); |
| ushort2 __ovld __cnfn convert_ushort2_rtp(float2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtp(float2); |
| ushort2 __ovld __cnfn convert_ushort2_rtn(float2); |
| ushort2 __ovld __cnfn convert_ushort2_sat_rtn(float2); |
| ushort2 __ovld __cnfn convert_ushort2(float2); |
| ushort2 __ovld __cnfn convert_ushort2_sat(float2); |
| int2 __ovld __cnfn convert_int2_rte(char2); |
| int2 __ovld __cnfn convert_int2_sat_rte(char2); |
| int2 __ovld __cnfn convert_int2_rtz(char2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(char2); |
| int2 __ovld __cnfn convert_int2_rtp(char2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(char2); |
| int2 __ovld __cnfn convert_int2_rtn(char2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(char2); |
| int2 __ovld __cnfn convert_int2(char2); |
| int2 __ovld __cnfn convert_int2_sat(char2); |
| int2 __ovld __cnfn convert_int2_rte(uchar2); |
| int2 __ovld __cnfn convert_int2_sat_rte(uchar2); |
| int2 __ovld __cnfn convert_int2_rtz(uchar2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(uchar2); |
| int2 __ovld __cnfn convert_int2_rtp(uchar2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(uchar2); |
| int2 __ovld __cnfn convert_int2_rtn(uchar2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(uchar2); |
| int2 __ovld __cnfn convert_int2(uchar2); |
| int2 __ovld __cnfn convert_int2_sat(uchar2); |
| int2 __ovld __cnfn convert_int2_rte(short2); |
| int2 __ovld __cnfn convert_int2_sat_rte(short2); |
| int2 __ovld __cnfn convert_int2_rtz(short2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(short2); |
| int2 __ovld __cnfn convert_int2_rtp(short2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(short2); |
| int2 __ovld __cnfn convert_int2_rtn(short2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(short2); |
| int2 __ovld __cnfn convert_int2(short2); |
| int2 __ovld __cnfn convert_int2_sat(short2); |
| int2 __ovld __cnfn convert_int2_rte(ushort2); |
| int2 __ovld __cnfn convert_int2_sat_rte(ushort2); |
| int2 __ovld __cnfn convert_int2_rtz(ushort2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(ushort2); |
| int2 __ovld __cnfn convert_int2_rtp(ushort2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(ushort2); |
| int2 __ovld __cnfn convert_int2_rtn(ushort2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(ushort2); |
| int2 __ovld __cnfn convert_int2(ushort2); |
| int2 __ovld __cnfn convert_int2_sat(ushort2); |
| int2 __ovld __cnfn convert_int2_rte(int2); |
| int2 __ovld __cnfn convert_int2_sat_rte(int2); |
| int2 __ovld __cnfn convert_int2_rtz(int2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(int2); |
| int2 __ovld __cnfn convert_int2_rtp(int2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(int2); |
| int2 __ovld __cnfn convert_int2_rtn(int2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(int2); |
| int2 __ovld __cnfn convert_int2(int2); |
| int2 __ovld __cnfn convert_int2_sat(int2); |
| int2 __ovld __cnfn convert_int2_rte(uint2); |
| int2 __ovld __cnfn convert_int2_sat_rte(uint2); |
| int2 __ovld __cnfn convert_int2_rtz(uint2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(uint2); |
| int2 __ovld __cnfn convert_int2_rtp(uint2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(uint2); |
| int2 __ovld __cnfn convert_int2_rtn(uint2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(uint2); |
| int2 __ovld __cnfn convert_int2(uint2); |
| int2 __ovld __cnfn convert_int2_sat(uint2); |
| int2 __ovld __cnfn convert_int2_rte(long2); |
| int2 __ovld __cnfn convert_int2_sat_rte(long2); |
| int2 __ovld __cnfn convert_int2_rtz(long2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(long2); |
| int2 __ovld __cnfn convert_int2_rtp(long2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(long2); |
| int2 __ovld __cnfn convert_int2_rtn(long2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(long2); |
| int2 __ovld __cnfn convert_int2(long2); |
| int2 __ovld __cnfn convert_int2_sat(long2); |
| int2 __ovld __cnfn convert_int2_rte(ulong2); |
| int2 __ovld __cnfn convert_int2_sat_rte(ulong2); |
| int2 __ovld __cnfn convert_int2_rtz(ulong2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(ulong2); |
| int2 __ovld __cnfn convert_int2_rtp(ulong2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(ulong2); |
| int2 __ovld __cnfn convert_int2_rtn(ulong2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(ulong2); |
| int2 __ovld __cnfn convert_int2(ulong2); |
| int2 __ovld __cnfn convert_int2_sat(ulong2); |
| int2 __ovld __cnfn convert_int2_rte(float2); |
| int2 __ovld __cnfn convert_int2_sat_rte(float2); |
| int2 __ovld __cnfn convert_int2_rtz(float2); |
| int2 __ovld __cnfn convert_int2_sat_rtz(float2); |
| int2 __ovld __cnfn convert_int2_rtp(float2); |
| int2 __ovld __cnfn convert_int2_sat_rtp(float2); |
| int2 __ovld __cnfn convert_int2_rtn(float2); |
| int2 __ovld __cnfn convert_int2_sat_rtn(float2); |
| int2 __ovld __cnfn convert_int2(float2); |
| int2 __ovld __cnfn convert_int2_sat(float2); |
| uint2 __ovld __cnfn convert_uint2_rte(char2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(char2); |
| uint2 __ovld __cnfn convert_uint2_rtz(char2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(char2); |
| uint2 __ovld __cnfn convert_uint2_rtp(char2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(char2); |
| uint2 __ovld __cnfn convert_uint2_rtn(char2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(char2); |
| uint2 __ovld __cnfn convert_uint2(char2); |
| uint2 __ovld __cnfn convert_uint2_sat(char2); |
| uint2 __ovld __cnfn convert_uint2_rte(uchar2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(uchar2); |
| uint2 __ovld __cnfn convert_uint2_rtz(uchar2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(uchar2); |
| uint2 __ovld __cnfn convert_uint2_rtp(uchar2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(uchar2); |
| uint2 __ovld __cnfn convert_uint2_rtn(uchar2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(uchar2); |
| uint2 __ovld __cnfn convert_uint2(uchar2); |
| uint2 __ovld __cnfn convert_uint2_sat(uchar2); |
| uint2 __ovld __cnfn convert_uint2_rte(short2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(short2); |
| uint2 __ovld __cnfn convert_uint2_rtz(short2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(short2); |
| uint2 __ovld __cnfn convert_uint2_rtp(short2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(short2); |
| uint2 __ovld __cnfn convert_uint2_rtn(short2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(short2); |
| uint2 __ovld __cnfn convert_uint2(short2); |
| uint2 __ovld __cnfn convert_uint2_sat(short2); |
| uint2 __ovld __cnfn convert_uint2_rte(ushort2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(ushort2); |
| uint2 __ovld __cnfn convert_uint2_rtz(ushort2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(ushort2); |
| uint2 __ovld __cnfn convert_uint2_rtp(ushort2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(ushort2); |
| uint2 __ovld __cnfn convert_uint2_rtn(ushort2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(ushort2); |
| uint2 __ovld __cnfn convert_uint2(ushort2); |
| uint2 __ovld __cnfn convert_uint2_sat(ushort2); |
| uint2 __ovld __cnfn convert_uint2_rte(int2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(int2); |
| uint2 __ovld __cnfn convert_uint2_rtz(int2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(int2); |
| uint2 __ovld __cnfn convert_uint2_rtp(int2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(int2); |
| uint2 __ovld __cnfn convert_uint2_rtn(int2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(int2); |
| uint2 __ovld __cnfn convert_uint2(int2); |
| uint2 __ovld __cnfn convert_uint2_sat(int2); |
| uint2 __ovld __cnfn convert_uint2_rte(uint2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(uint2); |
| uint2 __ovld __cnfn convert_uint2_rtz(uint2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(uint2); |
| uint2 __ovld __cnfn convert_uint2_rtp(uint2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(uint2); |
| uint2 __ovld __cnfn convert_uint2_rtn(uint2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(uint2); |
| uint2 __ovld __cnfn convert_uint2(uint2); |
| uint2 __ovld __cnfn convert_uint2_sat(uint2); |
| uint2 __ovld __cnfn convert_uint2_rte(long2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(long2); |
| uint2 __ovld __cnfn convert_uint2_rtz(long2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(long2); |
| uint2 __ovld __cnfn convert_uint2_rtp(long2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(long2); |
| uint2 __ovld __cnfn convert_uint2_rtn(long2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(long2); |
| uint2 __ovld __cnfn convert_uint2(long2); |
| uint2 __ovld __cnfn convert_uint2_sat(long2); |
| uint2 __ovld __cnfn convert_uint2_rte(ulong2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(ulong2); |
| uint2 __ovld __cnfn convert_uint2_rtz(ulong2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(ulong2); |
| uint2 __ovld __cnfn convert_uint2_rtp(ulong2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(ulong2); |
| uint2 __ovld __cnfn convert_uint2_rtn(ulong2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(ulong2); |
| uint2 __ovld __cnfn convert_uint2(ulong2); |
| uint2 __ovld __cnfn convert_uint2_sat(ulong2); |
| uint2 __ovld __cnfn convert_uint2_rte(float2); |
| uint2 __ovld __cnfn convert_uint2_sat_rte(float2); |
| uint2 __ovld __cnfn convert_uint2_rtz(float2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtz(float2); |
| uint2 __ovld __cnfn convert_uint2_rtp(float2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtp(float2); |
| uint2 __ovld __cnfn convert_uint2_rtn(float2); |
| uint2 __ovld __cnfn convert_uint2_sat_rtn(float2); |
| uint2 __ovld __cnfn convert_uint2(float2); |
| uint2 __ovld __cnfn convert_uint2_sat(float2); |
| long2 __ovld __cnfn convert_long2_rte(char2); |
| long2 __ovld __cnfn convert_long2_sat_rte(char2); |
| long2 __ovld __cnfn convert_long2_rtz(char2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(char2); |
| long2 __ovld __cnfn convert_long2_rtp(char2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(char2); |
| long2 __ovld __cnfn convert_long2_rtn(char2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(char2); |
| long2 __ovld __cnfn convert_long2(char2); |
| long2 __ovld __cnfn convert_long2_sat(char2); |
| long2 __ovld __cnfn convert_long2_rte(uchar2); |
| long2 __ovld __cnfn convert_long2_sat_rte(uchar2); |
| long2 __ovld __cnfn convert_long2_rtz(uchar2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(uchar2); |
| long2 __ovld __cnfn convert_long2_rtp(uchar2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(uchar2); |
| long2 __ovld __cnfn convert_long2_rtn(uchar2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(uchar2); |
| long2 __ovld __cnfn convert_long2(uchar2); |
| long2 __ovld __cnfn convert_long2_sat(uchar2); |
| long2 __ovld __cnfn convert_long2_rte(short2); |
| long2 __ovld __cnfn convert_long2_sat_rte(short2); |
| long2 __ovld __cnfn convert_long2_rtz(short2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(short2); |
| long2 __ovld __cnfn convert_long2_rtp(short2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(short2); |
| long2 __ovld __cnfn convert_long2_rtn(short2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(short2); |
| long2 __ovld __cnfn convert_long2(short2); |
| long2 __ovld __cnfn convert_long2_sat(short2); |
| long2 __ovld __cnfn convert_long2_rte(ushort2); |
| long2 __ovld __cnfn convert_long2_sat_rte(ushort2); |
| long2 __ovld __cnfn convert_long2_rtz(ushort2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(ushort2); |
| long2 __ovld __cnfn convert_long2_rtp(ushort2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(ushort2); |
| long2 __ovld __cnfn convert_long2_rtn(ushort2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(ushort2); |
| long2 __ovld __cnfn convert_long2(ushort2); |
| long2 __ovld __cnfn convert_long2_sat(ushort2); |
| long2 __ovld __cnfn convert_long2_rte(int2); |
| long2 __ovld __cnfn convert_long2_sat_rte(int2); |
| long2 __ovld __cnfn convert_long2_rtz(int2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(int2); |
| long2 __ovld __cnfn convert_long2_rtp(int2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(int2); |
| long2 __ovld __cnfn convert_long2_rtn(int2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(int2); |
| long2 __ovld __cnfn convert_long2(int2); |
| long2 __ovld __cnfn convert_long2_sat(int2); |
| long2 __ovld __cnfn convert_long2_rte(uint2); |
| long2 __ovld __cnfn convert_long2_sat_rte(uint2); |
| long2 __ovld __cnfn convert_long2_rtz(uint2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(uint2); |
| long2 __ovld __cnfn convert_long2_rtp(uint2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(uint2); |
| long2 __ovld __cnfn convert_long2_rtn(uint2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(uint2); |
| long2 __ovld __cnfn convert_long2(uint2); |
| long2 __ovld __cnfn convert_long2_sat(uint2); |
| long2 __ovld __cnfn convert_long2_rte(long2); |
| long2 __ovld __cnfn convert_long2_sat_rte(long2); |
| long2 __ovld __cnfn convert_long2_rtz(long2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(long2); |
| long2 __ovld __cnfn convert_long2_rtp(long2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(long2); |
| long2 __ovld __cnfn convert_long2_rtn(long2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(long2); |
| long2 __ovld __cnfn convert_long2(long2); |
| long2 __ovld __cnfn convert_long2_sat(long2); |
| long2 __ovld __cnfn convert_long2_rte(ulong2); |
| long2 __ovld __cnfn convert_long2_sat_rte(ulong2); |
| long2 __ovld __cnfn convert_long2_rtz(ulong2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(ulong2); |
| long2 __ovld __cnfn convert_long2_rtp(ulong2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(ulong2); |
| long2 __ovld __cnfn convert_long2_rtn(ulong2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(ulong2); |
| long2 __ovld __cnfn convert_long2(ulong2); |
| long2 __ovld __cnfn convert_long2_sat(ulong2); |
| long2 __ovld __cnfn convert_long2_rte(float2); |
| long2 __ovld __cnfn convert_long2_sat_rte(float2); |
| long2 __ovld __cnfn convert_long2_rtz(float2); |
| long2 __ovld __cnfn convert_long2_sat_rtz(float2); |
| long2 __ovld __cnfn convert_long2_rtp(float2); |
| long2 __ovld __cnfn convert_long2_sat_rtp(float2); |
| long2 __ovld __cnfn convert_long2_rtn(float2); |
| long2 __ovld __cnfn convert_long2_sat_rtn(float2); |
| long2 __ovld __cnfn convert_long2(float2); |
| long2 __ovld __cnfn convert_long2_sat(float2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(char2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(char2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(char2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(char2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(char2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(char2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(char2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(char2); |
| ulong2 __ovld __cnfn convert_ulong2(char2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(char2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(uchar2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(short2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(short2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(short2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(short2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(short2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(short2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(short2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(short2); |
| ulong2 __ovld __cnfn convert_ulong2(short2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(short2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(ushort2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(int2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(int2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(int2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(int2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(int2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(int2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(int2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(int2); |
| ulong2 __ovld __cnfn convert_ulong2(int2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(int2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(uint2); |
| ulong2 __ovld __cnfn convert_ulong2(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(uint2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(long2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(long2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(long2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(long2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(long2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(long2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(long2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(long2); |
| ulong2 __ovld __cnfn convert_ulong2(long2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(long2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(ulong2); |
| ulong2 __ovld __cnfn convert_ulong2_rte(float2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rte(float2); |
| ulong2 __ovld __cnfn convert_ulong2_rtz(float2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtz(float2); |
| ulong2 __ovld __cnfn convert_ulong2_rtp(float2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtp(float2); |
| ulong2 __ovld __cnfn convert_ulong2_rtn(float2); |
| ulong2 __ovld __cnfn convert_ulong2_sat_rtn(float2); |
| ulong2 __ovld __cnfn convert_ulong2(float2); |
| ulong2 __ovld __cnfn convert_ulong2_sat(float2); |
| float2 __ovld __cnfn convert_float2_rte(char2); |
| float2 __ovld __cnfn convert_float2_rtz(char2); |
| float2 __ovld __cnfn convert_float2_rtp(char2); |
| float2 __ovld __cnfn convert_float2_rtn(char2); |
| float2 __ovld __cnfn convert_float2(char2); |
| float2 __ovld __cnfn convert_float2_rte(uchar2); |
| float2 __ovld __cnfn convert_float2_rtz(uchar2); |
| float2 __ovld __cnfn convert_float2_rtp(uchar2); |
| float2 __ovld __cnfn convert_float2_rtn(uchar2); |
| float2 __ovld __cnfn convert_float2(uchar2); |
| float2 __ovld __cnfn convert_float2_rte(short2); |
| float2 __ovld __cnfn convert_float2_rtz(short2); |
| float2 __ovld __cnfn convert_float2_rtp(short2); |
| float2 __ovld __cnfn convert_float2_rtn(short2); |
| float2 __ovld __cnfn convert_float2(short2); |
| float2 __ovld __cnfn convert_float2_rte(ushort2); |
| float2 __ovld __cnfn convert_float2_rtz(ushort2); |
| float2 __ovld __cnfn convert_float2_rtp(ushort2); |
| float2 __ovld __cnfn convert_float2_rtn(ushort2); |
| float2 __ovld __cnfn convert_float2(ushort2); |
| float2 __ovld __cnfn convert_float2_rte(int2); |
| float2 __ovld __cnfn convert_float2_rtz(int2); |
| float2 __ovld __cnfn convert_float2_rtp(int2); |
| float2 __ovld __cnfn convert_float2_rtn(int2); |
| float2 __ovld __cnfn convert_float2(int2); |
| float2 __ovld __cnfn convert_float2_rte(uint2); |
| float2 __ovld __cnfn convert_float2_rtz(uint2); |
| float2 __ovld __cnfn convert_float2_rtp(uint2); |
| float2 __ovld __cnfn convert_float2_rtn(uint2); |
| float2 __ovld __cnfn convert_float2(uint2); |
| float2 __ovld __cnfn convert_float2_rte(long2); |
| float2 __ovld __cnfn convert_float2_rtz(long2); |
| float2 __ovld __cnfn convert_float2_rtp(long2); |
| float2 __ovld __cnfn convert_float2_rtn(long2); |
| float2 __ovld __cnfn convert_float2(long2); |
| float2 __ovld __cnfn convert_float2_rte(ulong2); |
| float2 __ovld __cnfn convert_float2_rtz(ulong2); |
| float2 __ovld __cnfn convert_float2_rtp(ulong2); |
| float2 __ovld __cnfn convert_float2_rtn(ulong2); |
| float2 __ovld __cnfn convert_float2(ulong2); |
| float2 __ovld __cnfn convert_float2_rte(float2); |
| float2 __ovld __cnfn convert_float2_rtz(float2); |
| float2 __ovld __cnfn convert_float2_rtp(float2); |
| float2 __ovld __cnfn convert_float2_rtn(float2); |
| float2 __ovld __cnfn convert_float2(float2); |
| char3 __ovld __cnfn convert_char3_rte(char3); |
| char3 __ovld __cnfn convert_char3_sat_rte(char3); |
| char3 __ovld __cnfn convert_char3_rtz(char3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(char3); |
| char3 __ovld __cnfn convert_char3_rtp(char3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(char3); |
| char3 __ovld __cnfn convert_char3_rtn(char3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(char3); |
| char3 __ovld __cnfn convert_char3(char3); |
| char3 __ovld __cnfn convert_char3_sat(char3); |
| char3 __ovld __cnfn convert_char3_rte(uchar3); |
| char3 __ovld __cnfn convert_char3_sat_rte(uchar3); |
| char3 __ovld __cnfn convert_char3_rtz(uchar3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(uchar3); |
| char3 __ovld __cnfn convert_char3_rtp(uchar3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(uchar3); |
| char3 __ovld __cnfn convert_char3_rtn(uchar3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(uchar3); |
| char3 __ovld __cnfn convert_char3(uchar3); |
| char3 __ovld __cnfn convert_char3_sat(uchar3); |
| char3 __ovld __cnfn convert_char3_rte(short3); |
| char3 __ovld __cnfn convert_char3_sat_rte(short3); |
| char3 __ovld __cnfn convert_char3_rtz(short3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(short3); |
| char3 __ovld __cnfn convert_char3_rtp(short3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(short3); |
| char3 __ovld __cnfn convert_char3_rtn(short3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(short3); |
| char3 __ovld __cnfn convert_char3(short3); |
| char3 __ovld __cnfn convert_char3_sat(short3); |
| char3 __ovld __cnfn convert_char3_rte(ushort3); |
| char3 __ovld __cnfn convert_char3_sat_rte(ushort3); |
| char3 __ovld __cnfn convert_char3_rtz(ushort3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(ushort3); |
| char3 __ovld __cnfn convert_char3_rtp(ushort3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(ushort3); |
| char3 __ovld __cnfn convert_char3_rtn(ushort3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(ushort3); |
| char3 __ovld __cnfn convert_char3(ushort3); |
| char3 __ovld __cnfn convert_char3_sat(ushort3); |
| char3 __ovld __cnfn convert_char3_rte(int3); |
| char3 __ovld __cnfn convert_char3_sat_rte(int3); |
| char3 __ovld __cnfn convert_char3_rtz(int3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(int3); |
| char3 __ovld __cnfn convert_char3_rtp(int3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(int3); |
| char3 __ovld __cnfn convert_char3_rtn(int3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(int3); |
| char3 __ovld __cnfn convert_char3(int3); |
| char3 __ovld __cnfn convert_char3_sat(int3); |
| char3 __ovld __cnfn convert_char3_rte(uint3); |
| char3 __ovld __cnfn convert_char3_sat_rte(uint3); |
| char3 __ovld __cnfn convert_char3_rtz(uint3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(uint3); |
| char3 __ovld __cnfn convert_char3_rtp(uint3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(uint3); |
| char3 __ovld __cnfn convert_char3_rtn(uint3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(uint3); |
| char3 __ovld __cnfn convert_char3(uint3); |
| char3 __ovld __cnfn convert_char3_sat(uint3); |
| char3 __ovld __cnfn convert_char3_rte(long3); |
| char3 __ovld __cnfn convert_char3_sat_rte(long3); |
| char3 __ovld __cnfn convert_char3_rtz(long3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(long3); |
| char3 __ovld __cnfn convert_char3_rtp(long3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(long3); |
| char3 __ovld __cnfn convert_char3_rtn(long3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(long3); |
| char3 __ovld __cnfn convert_char3(long3); |
| char3 __ovld __cnfn convert_char3_sat(long3); |
| char3 __ovld __cnfn convert_char3_rte(ulong3); |
| char3 __ovld __cnfn convert_char3_sat_rte(ulong3); |
| char3 __ovld __cnfn convert_char3_rtz(ulong3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(ulong3); |
| char3 __ovld __cnfn convert_char3_rtp(ulong3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(ulong3); |
| char3 __ovld __cnfn convert_char3_rtn(ulong3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(ulong3); |
| char3 __ovld __cnfn convert_char3(ulong3); |
| char3 __ovld __cnfn convert_char3_sat(ulong3); |
| char3 __ovld __cnfn convert_char3_rte(float3); |
| char3 __ovld __cnfn convert_char3_sat_rte(float3); |
| char3 __ovld __cnfn convert_char3_rtz(float3); |
| char3 __ovld __cnfn convert_char3_sat_rtz(float3); |
| char3 __ovld __cnfn convert_char3_rtp(float3); |
| char3 __ovld __cnfn convert_char3_sat_rtp(float3); |
| char3 __ovld __cnfn convert_char3_rtn(float3); |
| char3 __ovld __cnfn convert_char3_sat_rtn(float3); |
| char3 __ovld __cnfn convert_char3(float3); |
| char3 __ovld __cnfn convert_char3_sat(float3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(char3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(char3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(char3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(char3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(char3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(char3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(char3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(char3); |
| uchar3 __ovld __cnfn convert_uchar3(char3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(char3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(uchar3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(short3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(short3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(short3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(short3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(short3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(short3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(short3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(short3); |
| uchar3 __ovld __cnfn convert_uchar3(short3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(short3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(ushort3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(int3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(int3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(int3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(int3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(int3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(int3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(int3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(int3); |
| uchar3 __ovld __cnfn convert_uchar3(int3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(int3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(uint3); |
| uchar3 __ovld __cnfn convert_uchar3(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(uint3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(long3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(long3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(long3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(long3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(long3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(long3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(long3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(long3); |
| uchar3 __ovld __cnfn convert_uchar3(long3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(long3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(ulong3); |
| uchar3 __ovld __cnfn convert_uchar3_rte(float3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rte(float3); |
| uchar3 __ovld __cnfn convert_uchar3_rtz(float3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtz(float3); |
| uchar3 __ovld __cnfn convert_uchar3_rtp(float3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtp(float3); |
| uchar3 __ovld __cnfn convert_uchar3_rtn(float3); |
| uchar3 __ovld __cnfn convert_uchar3_sat_rtn(float3); |
| uchar3 __ovld __cnfn convert_uchar3(float3); |
| uchar3 __ovld __cnfn convert_uchar3_sat(float3); |
| short3 __ovld __cnfn convert_short3_rte(char3); |
| short3 __ovld __cnfn convert_short3_sat_rte(char3); |
| short3 __ovld __cnfn convert_short3_rtz(char3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(char3); |
| short3 __ovld __cnfn convert_short3_rtp(char3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(char3); |
| short3 __ovld __cnfn convert_short3_rtn(char3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(char3); |
| short3 __ovld __cnfn convert_short3(char3); |
| short3 __ovld __cnfn convert_short3_sat(char3); |
| short3 __ovld __cnfn convert_short3_rte(uchar3); |
| short3 __ovld __cnfn convert_short3_sat_rte(uchar3); |
| short3 __ovld __cnfn convert_short3_rtz(uchar3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(uchar3); |
| short3 __ovld __cnfn convert_short3_rtp(uchar3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(uchar3); |
| short3 __ovld __cnfn convert_short3_rtn(uchar3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(uchar3); |
| short3 __ovld __cnfn convert_short3(uchar3); |
| short3 __ovld __cnfn convert_short3_sat(uchar3); |
| short3 __ovld __cnfn convert_short3_rte(short3); |
| short3 __ovld __cnfn convert_short3_sat_rte(short3); |
| short3 __ovld __cnfn convert_short3_rtz(short3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(short3); |
| short3 __ovld __cnfn convert_short3_rtp(short3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(short3); |
| short3 __ovld __cnfn convert_short3_rtn(short3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(short3); |
| short3 __ovld __cnfn convert_short3(short3); |
| short3 __ovld __cnfn convert_short3_sat(short3); |
| short3 __ovld __cnfn convert_short3_rte(ushort3); |
| short3 __ovld __cnfn convert_short3_sat_rte(ushort3); |
| short3 __ovld __cnfn convert_short3_rtz(ushort3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(ushort3); |
| short3 __ovld __cnfn convert_short3_rtp(ushort3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(ushort3); |
| short3 __ovld __cnfn convert_short3_rtn(ushort3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(ushort3); |
| short3 __ovld __cnfn convert_short3(ushort3); |
| short3 __ovld __cnfn convert_short3_sat(ushort3); |
| short3 __ovld __cnfn convert_short3_rte(int3); |
| short3 __ovld __cnfn convert_short3_sat_rte(int3); |
| short3 __ovld __cnfn convert_short3_rtz(int3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(int3); |
| short3 __ovld __cnfn convert_short3_rtp(int3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(int3); |
| short3 __ovld __cnfn convert_short3_rtn(int3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(int3); |
| short3 __ovld __cnfn convert_short3(int3); |
| short3 __ovld __cnfn convert_short3_sat(int3); |
| short3 __ovld __cnfn convert_short3_rte(uint3); |
| short3 __ovld __cnfn convert_short3_sat_rte(uint3); |
| short3 __ovld __cnfn convert_short3_rtz(uint3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(uint3); |
| short3 __ovld __cnfn convert_short3_rtp(uint3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(uint3); |
| short3 __ovld __cnfn convert_short3_rtn(uint3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(uint3); |
| short3 __ovld __cnfn convert_short3(uint3); |
| short3 __ovld __cnfn convert_short3_sat(uint3); |
| short3 __ovld __cnfn convert_short3_rte(long3); |
| short3 __ovld __cnfn convert_short3_sat_rte(long3); |
| short3 __ovld __cnfn convert_short3_rtz(long3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(long3); |
| short3 __ovld __cnfn convert_short3_rtp(long3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(long3); |
| short3 __ovld __cnfn convert_short3_rtn(long3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(long3); |
| short3 __ovld __cnfn convert_short3(long3); |
| short3 __ovld __cnfn convert_short3_sat(long3); |
| short3 __ovld __cnfn convert_short3_rte(ulong3); |
| short3 __ovld __cnfn convert_short3_sat_rte(ulong3); |
| short3 __ovld __cnfn convert_short3_rtz(ulong3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(ulong3); |
| short3 __ovld __cnfn convert_short3_rtp(ulong3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(ulong3); |
| short3 __ovld __cnfn convert_short3_rtn(ulong3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(ulong3); |
| short3 __ovld __cnfn convert_short3(ulong3); |
| short3 __ovld __cnfn convert_short3_sat(ulong3); |
| short3 __ovld __cnfn convert_short3_rte(float3); |
| short3 __ovld __cnfn convert_short3_sat_rte(float3); |
| short3 __ovld __cnfn convert_short3_rtz(float3); |
| short3 __ovld __cnfn convert_short3_sat_rtz(float3); |
| short3 __ovld __cnfn convert_short3_rtp(float3); |
| short3 __ovld __cnfn convert_short3_sat_rtp(float3); |
| short3 __ovld __cnfn convert_short3_rtn(float3); |
| short3 __ovld __cnfn convert_short3_sat_rtn(float3); |
| short3 __ovld __cnfn convert_short3(float3); |
| short3 __ovld __cnfn convert_short3_sat(float3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(char3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(char3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(char3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(char3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(char3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(char3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(char3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(char3); |
| ushort3 __ovld __cnfn convert_ushort3(char3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(char3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(uchar3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(short3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(short3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(short3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(short3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(short3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(short3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(short3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(short3); |
| ushort3 __ovld __cnfn convert_ushort3(short3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(short3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(ushort3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(int3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(int3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(int3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(int3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(int3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(int3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(int3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(int3); |
| ushort3 __ovld __cnfn convert_ushort3(int3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(int3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(uint3); |
| ushort3 __ovld __cnfn convert_ushort3(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(uint3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(long3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(long3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(long3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(long3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(long3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(long3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(long3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(long3); |
| ushort3 __ovld __cnfn convert_ushort3(long3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(long3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(ulong3); |
| ushort3 __ovld __cnfn convert_ushort3_rte(float3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rte(float3); |
| ushort3 __ovld __cnfn convert_ushort3_rtz(float3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtz(float3); |
| ushort3 __ovld __cnfn convert_ushort3_rtp(float3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtp(float3); |
| ushort3 __ovld __cnfn convert_ushort3_rtn(float3); |
| ushort3 __ovld __cnfn convert_ushort3_sat_rtn(float3); |
| ushort3 __ovld __cnfn convert_ushort3(float3); |
| ushort3 __ovld __cnfn convert_ushort3_sat(float3); |
| int3 __ovld __cnfn convert_int3_rte(char3); |
| int3 __ovld __cnfn convert_int3_sat_rte(char3); |
| int3 __ovld __cnfn convert_int3_rtz(char3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(char3); |
| int3 __ovld __cnfn convert_int3_rtp(char3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(char3); |
| int3 __ovld __cnfn convert_int3_rtn(char3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(char3); |
| int3 __ovld __cnfn convert_int3(char3); |
| int3 __ovld __cnfn convert_int3_sat(char3); |
| int3 __ovld __cnfn convert_int3_rte(uchar3); |
| int3 __ovld __cnfn convert_int3_sat_rte(uchar3); |
| int3 __ovld __cnfn convert_int3_rtz(uchar3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(uchar3); |
| int3 __ovld __cnfn convert_int3_rtp(uchar3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(uchar3); |
| int3 __ovld __cnfn convert_int3_rtn(uchar3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(uchar3); |
| int3 __ovld __cnfn convert_int3(uchar3); |
| int3 __ovld __cnfn convert_int3_sat(uchar3); |
| int3 __ovld __cnfn convert_int3_rte(short3); |
| int3 __ovld __cnfn convert_int3_sat_rte(short3); |
| int3 __ovld __cnfn convert_int3_rtz(short3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(short3); |
| int3 __ovld __cnfn convert_int3_rtp(short3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(short3); |
| int3 __ovld __cnfn convert_int3_rtn(short3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(short3); |
| int3 __ovld __cnfn convert_int3(short3); |
| int3 __ovld __cnfn convert_int3_sat(short3); |
| int3 __ovld __cnfn convert_int3_rte(ushort3); |
| int3 __ovld __cnfn convert_int3_sat_rte(ushort3); |
| int3 __ovld __cnfn convert_int3_rtz(ushort3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(ushort3); |
| int3 __ovld __cnfn convert_int3_rtp(ushort3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(ushort3); |
| int3 __ovld __cnfn convert_int3_rtn(ushort3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(ushort3); |
| int3 __ovld __cnfn convert_int3(ushort3); |
| int3 __ovld __cnfn convert_int3_sat(ushort3); |
| int3 __ovld __cnfn convert_int3_rte(int3); |
| int3 __ovld __cnfn convert_int3_sat_rte(int3); |
| int3 __ovld __cnfn convert_int3_rtz(int3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(int3); |
| int3 __ovld __cnfn convert_int3_rtp(int3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(int3); |
| int3 __ovld __cnfn convert_int3_rtn(int3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(int3); |
| int3 __ovld __cnfn convert_int3(int3); |
| int3 __ovld __cnfn convert_int3_sat(int3); |
| int3 __ovld __cnfn convert_int3_rte(uint3); |
| int3 __ovld __cnfn convert_int3_sat_rte(uint3); |
| int3 __ovld __cnfn convert_int3_rtz(uint3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(uint3); |
| int3 __ovld __cnfn convert_int3_rtp(uint3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(uint3); |
| int3 __ovld __cnfn convert_int3_rtn(uint3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(uint3); |
| int3 __ovld __cnfn convert_int3(uint3); |
| int3 __ovld __cnfn convert_int3_sat(uint3); |
| int3 __ovld __cnfn convert_int3_rte(long3); |
| int3 __ovld __cnfn convert_int3_sat_rte(long3); |
| int3 __ovld __cnfn convert_int3_rtz(long3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(long3); |
| int3 __ovld __cnfn convert_int3_rtp(long3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(long3); |
| int3 __ovld __cnfn convert_int3_rtn(long3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(long3); |
| int3 __ovld __cnfn convert_int3(long3); |
| int3 __ovld __cnfn convert_int3_sat(long3); |
| int3 __ovld __cnfn convert_int3_rte(ulong3); |
| int3 __ovld __cnfn convert_int3_sat_rte(ulong3); |
| int3 __ovld __cnfn convert_int3_rtz(ulong3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(ulong3); |
| int3 __ovld __cnfn convert_int3_rtp(ulong3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(ulong3); |
| int3 __ovld __cnfn convert_int3_rtn(ulong3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(ulong3); |
| int3 __ovld __cnfn convert_int3(ulong3); |
| int3 __ovld __cnfn convert_int3_sat(ulong3); |
| int3 __ovld __cnfn convert_int3_rte(float3); |
| int3 __ovld __cnfn convert_int3_sat_rte(float3); |
| int3 __ovld __cnfn convert_int3_rtz(float3); |
| int3 __ovld __cnfn convert_int3_sat_rtz(float3); |
| int3 __ovld __cnfn convert_int3_rtp(float3); |
| int3 __ovld __cnfn convert_int3_sat_rtp(float3); |
| int3 __ovld __cnfn convert_int3_rtn(float3); |
| int3 __ovld __cnfn convert_int3_sat_rtn(float3); |
| int3 __ovld __cnfn convert_int3(float3); |
| int3 __ovld __cnfn convert_int3_sat(float3); |
| uint3 __ovld __cnfn convert_uint3_rte(char3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(char3); |
| uint3 __ovld __cnfn convert_uint3_rtz(char3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(char3); |
| uint3 __ovld __cnfn convert_uint3_rtp(char3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(char3); |
| uint3 __ovld __cnfn convert_uint3_rtn(char3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(char3); |
| uint3 __ovld __cnfn convert_uint3(char3); |
| uint3 __ovld __cnfn convert_uint3_sat(char3); |
| uint3 __ovld __cnfn convert_uint3_rte(uchar3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(uchar3); |
| uint3 __ovld __cnfn convert_uint3_rtz(uchar3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(uchar3); |
| uint3 __ovld __cnfn convert_uint3_rtp(uchar3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(uchar3); |
| uint3 __ovld __cnfn convert_uint3_rtn(uchar3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(uchar3); |
| uint3 __ovld __cnfn convert_uint3(uchar3); |
| uint3 __ovld __cnfn convert_uint3_sat(uchar3); |
| uint3 __ovld __cnfn convert_uint3_rte(short3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(short3); |
| uint3 __ovld __cnfn convert_uint3_rtz(short3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(short3); |
| uint3 __ovld __cnfn convert_uint3_rtp(short3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(short3); |
| uint3 __ovld __cnfn convert_uint3_rtn(short3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(short3); |
| uint3 __ovld __cnfn convert_uint3(short3); |
| uint3 __ovld __cnfn convert_uint3_sat(short3); |
| uint3 __ovld __cnfn convert_uint3_rte(ushort3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(ushort3); |
| uint3 __ovld __cnfn convert_uint3_rtz(ushort3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(ushort3); |
| uint3 __ovld __cnfn convert_uint3_rtp(ushort3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(ushort3); |
| uint3 __ovld __cnfn convert_uint3_rtn(ushort3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(ushort3); |
| uint3 __ovld __cnfn convert_uint3(ushort3); |
| uint3 __ovld __cnfn convert_uint3_sat(ushort3); |
| uint3 __ovld __cnfn convert_uint3_rte(int3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(int3); |
| uint3 __ovld __cnfn convert_uint3_rtz(int3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(int3); |
| uint3 __ovld __cnfn convert_uint3_rtp(int3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(int3); |
| uint3 __ovld __cnfn convert_uint3_rtn(int3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(int3); |
| uint3 __ovld __cnfn convert_uint3(int3); |
| uint3 __ovld __cnfn convert_uint3_sat(int3); |
| uint3 __ovld __cnfn convert_uint3_rte(uint3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(uint3); |
| uint3 __ovld __cnfn convert_uint3_rtz(uint3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(uint3); |
| uint3 __ovld __cnfn convert_uint3_rtp(uint3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(uint3); |
| uint3 __ovld __cnfn convert_uint3_rtn(uint3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(uint3); |
| uint3 __ovld __cnfn convert_uint3(uint3); |
| uint3 __ovld __cnfn convert_uint3_sat(uint3); |
| uint3 __ovld __cnfn convert_uint3_rte(long3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(long3); |
| uint3 __ovld __cnfn convert_uint3_rtz(long3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(long3); |
| uint3 __ovld __cnfn convert_uint3_rtp(long3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(long3); |
| uint3 __ovld __cnfn convert_uint3_rtn(long3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(long3); |
| uint3 __ovld __cnfn convert_uint3(long3); |
| uint3 __ovld __cnfn convert_uint3_sat(long3); |
| uint3 __ovld __cnfn convert_uint3_rte(ulong3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(ulong3); |
| uint3 __ovld __cnfn convert_uint3_rtz(ulong3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(ulong3); |
| uint3 __ovld __cnfn convert_uint3_rtp(ulong3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(ulong3); |
| uint3 __ovld __cnfn convert_uint3_rtn(ulong3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(ulong3); |
| uint3 __ovld __cnfn convert_uint3(ulong3); |
| uint3 __ovld __cnfn convert_uint3_sat(ulong3); |
| uint3 __ovld __cnfn convert_uint3_rte(float3); |
| uint3 __ovld __cnfn convert_uint3_sat_rte(float3); |
| uint3 __ovld __cnfn convert_uint3_rtz(float3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtz(float3); |
| uint3 __ovld __cnfn convert_uint3_rtp(float3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtp(float3); |
| uint3 __ovld __cnfn convert_uint3_rtn(float3); |
| uint3 __ovld __cnfn convert_uint3_sat_rtn(float3); |
| uint3 __ovld __cnfn convert_uint3(float3); |
| uint3 __ovld __cnfn convert_uint3_sat(float3); |
| long3 __ovld __cnfn convert_long3_rte(char3); |
| long3 __ovld __cnfn convert_long3_sat_rte(char3); |
| long3 __ovld __cnfn convert_long3_rtz(char3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(char3); |
| long3 __ovld __cnfn convert_long3_rtp(char3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(char3); |
| long3 __ovld __cnfn convert_long3_rtn(char3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(char3); |
| long3 __ovld __cnfn convert_long3(char3); |
| long3 __ovld __cnfn convert_long3_sat(char3); |
| long3 __ovld __cnfn convert_long3_rte(uchar3); |
| long3 __ovld __cnfn convert_long3_sat_rte(uchar3); |
| long3 __ovld __cnfn convert_long3_rtz(uchar3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(uchar3); |
| long3 __ovld __cnfn convert_long3_rtp(uchar3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(uchar3); |
| long3 __ovld __cnfn convert_long3_rtn(uchar3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(uchar3); |
| long3 __ovld __cnfn convert_long3(uchar3); |
| long3 __ovld __cnfn convert_long3_sat(uchar3); |
| long3 __ovld __cnfn convert_long3_rte(short3); |
| long3 __ovld __cnfn convert_long3_sat_rte(short3); |
| long3 __ovld __cnfn convert_long3_rtz(short3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(short3); |
| long3 __ovld __cnfn convert_long3_rtp(short3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(short3); |
| long3 __ovld __cnfn convert_long3_rtn(short3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(short3); |
| long3 __ovld __cnfn convert_long3(short3); |
| long3 __ovld __cnfn convert_long3_sat(short3); |
| long3 __ovld __cnfn convert_long3_rte(ushort3); |
| long3 __ovld __cnfn convert_long3_sat_rte(ushort3); |
| long3 __ovld __cnfn convert_long3_rtz(ushort3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(ushort3); |
| long3 __ovld __cnfn convert_long3_rtp(ushort3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(ushort3); |
| long3 __ovld __cnfn convert_long3_rtn(ushort3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(ushort3); |
| long3 __ovld __cnfn convert_long3(ushort3); |
| long3 __ovld __cnfn convert_long3_sat(ushort3); |
| long3 __ovld __cnfn convert_long3_rte(int3); |
| long3 __ovld __cnfn convert_long3_sat_rte(int3); |
| long3 __ovld __cnfn convert_long3_rtz(int3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(int3); |
| long3 __ovld __cnfn convert_long3_rtp(int3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(int3); |
| long3 __ovld __cnfn convert_long3_rtn(int3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(int3); |
| long3 __ovld __cnfn convert_long3(int3); |
| long3 __ovld __cnfn convert_long3_sat(int3); |
| long3 __ovld __cnfn convert_long3_rte(uint3); |
| long3 __ovld __cnfn convert_long3_sat_rte(uint3); |
| long3 __ovld __cnfn convert_long3_rtz(uint3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(uint3); |
| long3 __ovld __cnfn convert_long3_rtp(uint3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(uint3); |
| long3 __ovld __cnfn convert_long3_rtn(uint3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(uint3); |
| long3 __ovld __cnfn convert_long3(uint3); |
| long3 __ovld __cnfn convert_long3_sat(uint3); |
| long3 __ovld __cnfn convert_long3_rte(long3); |
| long3 __ovld __cnfn convert_long3_sat_rte(long3); |
| long3 __ovld __cnfn convert_long3_rtz(long3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(long3); |
| long3 __ovld __cnfn convert_long3_rtp(long3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(long3); |
| long3 __ovld __cnfn convert_long3_rtn(long3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(long3); |
| long3 __ovld __cnfn convert_long3(long3); |
| long3 __ovld __cnfn convert_long3_sat(long3); |
| long3 __ovld __cnfn convert_long3_rte(ulong3); |
| long3 __ovld __cnfn convert_long3_sat_rte(ulong3); |
| long3 __ovld __cnfn convert_long3_rtz(ulong3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(ulong3); |
| long3 __ovld __cnfn convert_long3_rtp(ulong3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(ulong3); |
| long3 __ovld __cnfn convert_long3_rtn(ulong3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(ulong3); |
| long3 __ovld __cnfn convert_long3(ulong3); |
| long3 __ovld __cnfn convert_long3_sat(ulong3); |
| long3 __ovld __cnfn convert_long3_rte(float3); |
| long3 __ovld __cnfn convert_long3_sat_rte(float3); |
| long3 __ovld __cnfn convert_long3_rtz(float3); |
| long3 __ovld __cnfn convert_long3_sat_rtz(float3); |
| long3 __ovld __cnfn convert_long3_rtp(float3); |
| long3 __ovld __cnfn convert_long3_sat_rtp(float3); |
| long3 __ovld __cnfn convert_long3_rtn(float3); |
| long3 __ovld __cnfn convert_long3_sat_rtn(float3); |
| long3 __ovld __cnfn convert_long3(float3); |
| long3 __ovld __cnfn convert_long3_sat(float3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(char3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(char3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(char3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(char3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(char3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(char3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(char3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(char3); |
| ulong3 __ovld __cnfn convert_ulong3(char3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(char3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(uchar3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(short3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(short3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(short3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(short3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(short3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(short3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(short3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(short3); |
| ulong3 __ovld __cnfn convert_ulong3(short3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(short3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(ushort3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(int3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(int3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(int3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(int3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(int3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(int3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(int3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(int3); |
| ulong3 __ovld __cnfn convert_ulong3(int3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(int3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(uint3); |
| ulong3 __ovld __cnfn convert_ulong3(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(uint3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(long3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(long3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(long3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(long3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(long3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(long3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(long3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(long3); |
| ulong3 __ovld __cnfn convert_ulong3(long3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(long3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(ulong3); |
| ulong3 __ovld __cnfn convert_ulong3_rte(float3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rte(float3); |
| ulong3 __ovld __cnfn convert_ulong3_rtz(float3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtz(float3); |
| ulong3 __ovld __cnfn convert_ulong3_rtp(float3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtp(float3); |
| ulong3 __ovld __cnfn convert_ulong3_rtn(float3); |
| ulong3 __ovld __cnfn convert_ulong3_sat_rtn(float3); |
| ulong3 __ovld __cnfn convert_ulong3(float3); |
| ulong3 __ovld __cnfn convert_ulong3_sat(float3); |
| float3 __ovld __cnfn convert_float3_rte(char3); |
| float3 __ovld __cnfn convert_float3_rtz(char3); |
| float3 __ovld __cnfn convert_float3_rtp(char3); |
| float3 __ovld __cnfn convert_float3_rtn(char3); |
| float3 __ovld __cnfn convert_float3(char3); |
| float3 __ovld __cnfn convert_float3_rte(uchar3); |
| float3 __ovld __cnfn convert_float3_rtz(uchar3); |
| float3 __ovld __cnfn convert_float3_rtp(uchar3); |
| float3 __ovld __cnfn convert_float3_rtn(uchar3); |
| float3 __ovld __cnfn convert_float3(uchar3); |
| float3 __ovld __cnfn convert_float3_rte(short3); |
| float3 __ovld __cnfn convert_float3_rtz(short3); |
| float3 __ovld __cnfn convert_float3_rtp(short3); |
| float3 __ovld __cnfn convert_float3_rtn(short3); |
| float3 __ovld __cnfn convert_float3(short3); |
| float3 __ovld __cnfn convert_float3_rte(ushort3); |
| float3 __ovld __cnfn convert_float3_rtz(ushort3); |
| float3 __ovld __cnfn convert_float3_rtp(ushort3); |
| float3 __ovld __cnfn convert_float3_rtn(ushort3); |
| float3 __ovld __cnfn convert_float3(ushort3); |
| float3 __ovld __cnfn convert_float3_rte(int3); |
| float3 __ovld __cnfn convert_float3_rtz(int3); |
| float3 __ovld __cnfn convert_float3_rtp(int3); |
| float3 __ovld __cnfn convert_float3_rtn(int3); |
| float3 __ovld __cnfn convert_float3(int3); |
| float3 __ovld __cnfn convert_float3_rte(uint3); |
| float3 __ovld __cnfn convert_float3_rtz(uint3); |
| float3 __ovld __cnfn convert_float3_rtp(uint3); |
| float3 __ovld __cnfn convert_float3_rtn(uint3); |
| float3 __ovld __cnfn convert_float3(uint3); |
| float3 __ovld __cnfn convert_float3_rte(long3); |
| float3 __ovld __cnfn convert_float3_rtz(long3); |
| float3 __ovld __cnfn convert_float3_rtp(long3); |
| float3 __ovld __cnfn convert_float3_rtn(long3); |
| float3 __ovld __cnfn convert_float3(long3); |
| float3 __ovld __cnfn convert_float3_rte(ulong3); |
| float3 __ovld __cnfn convert_float3_rtz(ulong3); |
| float3 __ovld __cnfn convert_float3_rtp(ulong3); |
| float3 __ovld __cnfn convert_float3_rtn(ulong3); |
| float3 __ovld __cnfn convert_float3(ulong3); |
| float3 __ovld __cnfn convert_float3_rte(float3); |
| float3 __ovld __cnfn convert_float3_rtz(float3); |
| float3 __ovld __cnfn convert_float3_rtp(float3); |
| float3 __ovld __cnfn convert_float3_rtn(float3); |
| float3 __ovld __cnfn convert_float3(float3); |
| char4 __ovld __cnfn convert_char4_rte(char4); |
| char4 __ovld __cnfn convert_char4_sat_rte(char4); |
| char4 __ovld __cnfn convert_char4_rtz(char4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(char4); |
| char4 __ovld __cnfn convert_char4_rtp(char4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(char4); |
| char4 __ovld __cnfn convert_char4_rtn(char4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(char4); |
| char4 __ovld __cnfn convert_char4(char4); |
| char4 __ovld __cnfn convert_char4_sat(char4); |
| char4 __ovld __cnfn convert_char4_rte(uchar4); |
| char4 __ovld __cnfn convert_char4_sat_rte(uchar4); |
| char4 __ovld __cnfn convert_char4_rtz(uchar4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(uchar4); |
| char4 __ovld __cnfn convert_char4_rtp(uchar4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(uchar4); |
| char4 __ovld __cnfn convert_char4_rtn(uchar4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(uchar4); |
| char4 __ovld __cnfn convert_char4(uchar4); |
| char4 __ovld __cnfn convert_char4_sat(uchar4); |
| char4 __ovld __cnfn convert_char4_rte(short4); |
| char4 __ovld __cnfn convert_char4_sat_rte(short4); |
| char4 __ovld __cnfn convert_char4_rtz(short4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(short4); |
| char4 __ovld __cnfn convert_char4_rtp(short4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(short4); |
| char4 __ovld __cnfn convert_char4_rtn(short4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(short4); |
| char4 __ovld __cnfn convert_char4(short4); |
| char4 __ovld __cnfn convert_char4_sat(short4); |
| char4 __ovld __cnfn convert_char4_rte(ushort4); |
| char4 __ovld __cnfn convert_char4_sat_rte(ushort4); |
| char4 __ovld __cnfn convert_char4_rtz(ushort4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(ushort4); |
| char4 __ovld __cnfn convert_char4_rtp(ushort4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(ushort4); |
| char4 __ovld __cnfn convert_char4_rtn(ushort4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(ushort4); |
| char4 __ovld __cnfn convert_char4(ushort4); |
| char4 __ovld __cnfn convert_char4_sat(ushort4); |
| char4 __ovld __cnfn convert_char4_rte(int4); |
| char4 __ovld __cnfn convert_char4_sat_rte(int4); |
| char4 __ovld __cnfn convert_char4_rtz(int4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(int4); |
| char4 __ovld __cnfn convert_char4_rtp(int4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(int4); |
| char4 __ovld __cnfn convert_char4_rtn(int4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(int4); |
| char4 __ovld __cnfn convert_char4(int4); |
| char4 __ovld __cnfn convert_char4_sat(int4); |
| char4 __ovld __cnfn convert_char4_rte(uint4); |
| char4 __ovld __cnfn convert_char4_sat_rte(uint4); |
| char4 __ovld __cnfn convert_char4_rtz(uint4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(uint4); |
| char4 __ovld __cnfn convert_char4_rtp(uint4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(uint4); |
| char4 __ovld __cnfn convert_char4_rtn(uint4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(uint4); |
| char4 __ovld __cnfn convert_char4(uint4); |
| char4 __ovld __cnfn convert_char4_sat(uint4); |
| char4 __ovld __cnfn convert_char4_rte(long4); |
| char4 __ovld __cnfn convert_char4_sat_rte(long4); |
| char4 __ovld __cnfn convert_char4_rtz(long4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(long4); |
| char4 __ovld __cnfn convert_char4_rtp(long4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(long4); |
| char4 __ovld __cnfn convert_char4_rtn(long4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(long4); |
| char4 __ovld __cnfn convert_char4(long4); |
| char4 __ovld __cnfn convert_char4_sat(long4); |
| char4 __ovld __cnfn convert_char4_rte(ulong4); |
| char4 __ovld __cnfn convert_char4_sat_rte(ulong4); |
| char4 __ovld __cnfn convert_char4_rtz(ulong4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(ulong4); |
| char4 __ovld __cnfn convert_char4_rtp(ulong4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(ulong4); |
| char4 __ovld __cnfn convert_char4_rtn(ulong4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(ulong4); |
| char4 __ovld __cnfn convert_char4(ulong4); |
| char4 __ovld __cnfn convert_char4_sat(ulong4); |
| char4 __ovld __cnfn convert_char4_rte(float4); |
| char4 __ovld __cnfn convert_char4_sat_rte(float4); |
| char4 __ovld __cnfn convert_char4_rtz(float4); |
| char4 __ovld __cnfn convert_char4_sat_rtz(float4); |
| char4 __ovld __cnfn convert_char4_rtp(float4); |
| char4 __ovld __cnfn convert_char4_sat_rtp(float4); |
| char4 __ovld __cnfn convert_char4_rtn(float4); |
| char4 __ovld __cnfn convert_char4_sat_rtn(float4); |
| char4 __ovld __cnfn convert_char4(float4); |
| char4 __ovld __cnfn convert_char4_sat(float4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(char4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(char4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(char4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(char4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(char4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(char4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(char4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(char4); |
| uchar4 __ovld __cnfn convert_uchar4(char4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(char4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(uchar4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(short4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(short4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(short4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(short4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(short4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(short4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(short4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(short4); |
| uchar4 __ovld __cnfn convert_uchar4(short4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(short4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(ushort4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(int4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(int4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(int4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(int4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(int4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(int4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(int4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(int4); |
| uchar4 __ovld __cnfn convert_uchar4(int4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(int4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(uint4); |
| uchar4 __ovld __cnfn convert_uchar4(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(uint4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(long4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(long4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(long4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(long4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(long4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(long4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(long4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(long4); |
| uchar4 __ovld __cnfn convert_uchar4(long4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(long4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(ulong4); |
| uchar4 __ovld __cnfn convert_uchar4_rte(float4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rte(float4); |
| uchar4 __ovld __cnfn convert_uchar4_rtz(float4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtz(float4); |
| uchar4 __ovld __cnfn convert_uchar4_rtp(float4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtp(float4); |
| uchar4 __ovld __cnfn convert_uchar4_rtn(float4); |
| uchar4 __ovld __cnfn convert_uchar4_sat_rtn(float4); |
| uchar4 __ovld __cnfn convert_uchar4(float4); |
| uchar4 __ovld __cnfn convert_uchar4_sat(float4); |
| short4 __ovld __cnfn convert_short4_rte(char4); |
| short4 __ovld __cnfn convert_short4_sat_rte(char4); |
| short4 __ovld __cnfn convert_short4_rtz(char4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(char4); |
| short4 __ovld __cnfn convert_short4_rtp(char4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(char4); |
| short4 __ovld __cnfn convert_short4_rtn(char4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(char4); |
| short4 __ovld __cnfn convert_short4(char4); |
| short4 __ovld __cnfn convert_short4_sat(char4); |
| short4 __ovld __cnfn convert_short4_rte(uchar4); |
| short4 __ovld __cnfn convert_short4_sat_rte(uchar4); |
| short4 __ovld __cnfn convert_short4_rtz(uchar4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(uchar4); |
| short4 __ovld __cnfn convert_short4_rtp(uchar4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(uchar4); |
| short4 __ovld __cnfn convert_short4_rtn(uchar4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(uchar4); |
| short4 __ovld __cnfn convert_short4(uchar4); |
| short4 __ovld __cnfn convert_short4_sat(uchar4); |
| short4 __ovld __cnfn convert_short4_rte(short4); |
| short4 __ovld __cnfn convert_short4_sat_rte(short4); |
| short4 __ovld __cnfn convert_short4_rtz(short4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(short4); |
| short4 __ovld __cnfn convert_short4_rtp(short4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(short4); |
| short4 __ovld __cnfn convert_short4_rtn(short4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(short4); |
| short4 __ovld __cnfn convert_short4(short4); |
| short4 __ovld __cnfn convert_short4_sat(short4); |
| short4 __ovld __cnfn convert_short4_rte(ushort4); |
| short4 __ovld __cnfn convert_short4_sat_rte(ushort4); |
| short4 __ovld __cnfn convert_short4_rtz(ushort4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(ushort4); |
| short4 __ovld __cnfn convert_short4_rtp(ushort4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(ushort4); |
| short4 __ovld __cnfn convert_short4_rtn(ushort4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(ushort4); |
| short4 __ovld __cnfn convert_short4(ushort4); |
| short4 __ovld __cnfn convert_short4_sat(ushort4); |
| short4 __ovld __cnfn convert_short4_rte(int4); |
| short4 __ovld __cnfn convert_short4_sat_rte(int4); |
| short4 __ovld __cnfn convert_short4_rtz(int4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(int4); |
| short4 __ovld __cnfn convert_short4_rtp(int4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(int4); |
| short4 __ovld __cnfn convert_short4_rtn(int4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(int4); |
| short4 __ovld __cnfn convert_short4(int4); |
| short4 __ovld __cnfn convert_short4_sat(int4); |
| short4 __ovld __cnfn convert_short4_rte(uint4); |
| short4 __ovld __cnfn convert_short4_sat_rte(uint4); |
| short4 __ovld __cnfn convert_short4_rtz(uint4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(uint4); |
| short4 __ovld __cnfn convert_short4_rtp(uint4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(uint4); |
| short4 __ovld __cnfn convert_short4_rtn(uint4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(uint4); |
| short4 __ovld __cnfn convert_short4(uint4); |
| short4 __ovld __cnfn convert_short4_sat(uint4); |
| short4 __ovld __cnfn convert_short4_rte(long4); |
| short4 __ovld __cnfn convert_short4_sat_rte(long4); |
| short4 __ovld __cnfn convert_short4_rtz(long4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(long4); |
| short4 __ovld __cnfn convert_short4_rtp(long4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(long4); |
| short4 __ovld __cnfn convert_short4_rtn(long4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(long4); |
| short4 __ovld __cnfn convert_short4(long4); |
| short4 __ovld __cnfn convert_short4_sat(long4); |
| short4 __ovld __cnfn convert_short4_rte(ulong4); |
| short4 __ovld __cnfn convert_short4_sat_rte(ulong4); |
| short4 __ovld __cnfn convert_short4_rtz(ulong4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(ulong4); |
| short4 __ovld __cnfn convert_short4_rtp(ulong4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(ulong4); |
| short4 __ovld __cnfn convert_short4_rtn(ulong4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(ulong4); |
| short4 __ovld __cnfn convert_short4(ulong4); |
| short4 __ovld __cnfn convert_short4_sat(ulong4); |
| short4 __ovld __cnfn convert_short4_rte(float4); |
| short4 __ovld __cnfn convert_short4_sat_rte(float4); |
| short4 __ovld __cnfn convert_short4_rtz(float4); |
| short4 __ovld __cnfn convert_short4_sat_rtz(float4); |
| short4 __ovld __cnfn convert_short4_rtp(float4); |
| short4 __ovld __cnfn convert_short4_sat_rtp(float4); |
| short4 __ovld __cnfn convert_short4_rtn(float4); |
| short4 __ovld __cnfn convert_short4_sat_rtn(float4); |
| short4 __ovld __cnfn convert_short4(float4); |
| short4 __ovld __cnfn convert_short4_sat(float4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(char4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(char4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(char4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(char4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(char4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(char4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(char4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(char4); |
| ushort4 __ovld __cnfn convert_ushort4(char4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(char4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(uchar4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(short4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(short4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(short4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(short4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(short4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(short4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(short4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(short4); |
| ushort4 __ovld __cnfn convert_ushort4(short4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(short4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(ushort4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(int4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(int4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(int4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(int4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(int4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(int4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(int4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(int4); |
| ushort4 __ovld __cnfn convert_ushort4(int4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(int4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(uint4); |
| ushort4 __ovld __cnfn convert_ushort4(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(uint4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(long4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(long4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(long4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(long4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(long4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(long4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(long4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(long4); |
| ushort4 __ovld __cnfn convert_ushort4(long4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(long4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(ulong4); |
| ushort4 __ovld __cnfn convert_ushort4_rte(float4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rte(float4); |
| ushort4 __ovld __cnfn convert_ushort4_rtz(float4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtz(float4); |
| ushort4 __ovld __cnfn convert_ushort4_rtp(float4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtp(float4); |
| ushort4 __ovld __cnfn convert_ushort4_rtn(float4); |
| ushort4 __ovld __cnfn convert_ushort4_sat_rtn(float4); |
| ushort4 __ovld __cnfn convert_ushort4(float4); |
| ushort4 __ovld __cnfn convert_ushort4_sat(float4); |
| int4 __ovld __cnfn convert_int4_rte(char4); |
| int4 __ovld __cnfn convert_int4_sat_rte(char4); |
| int4 __ovld __cnfn convert_int4_rtz(char4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(char4); |
| int4 __ovld __cnfn convert_int4_rtp(char4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(char4); |
| int4 __ovld __cnfn convert_int4_rtn(char4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(char4); |
| int4 __ovld __cnfn convert_int4(char4); |
| int4 __ovld __cnfn convert_int4_sat(char4); |
| int4 __ovld __cnfn convert_int4_rte(uchar4); |
| int4 __ovld __cnfn convert_int4_sat_rte(uchar4); |
| int4 __ovld __cnfn convert_int4_rtz(uchar4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(uchar4); |
| int4 __ovld __cnfn convert_int4_rtp(uchar4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(uchar4); |
| int4 __ovld __cnfn convert_int4_rtn(uchar4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(uchar4); |
| int4 __ovld __cnfn convert_int4(uchar4); |
| int4 __ovld __cnfn convert_int4_sat(uchar4); |
| int4 __ovld __cnfn convert_int4_rte(short4); |
| int4 __ovld __cnfn convert_int4_sat_rte(short4); |
| int4 __ovld __cnfn convert_int4_rtz(short4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(short4); |
| int4 __ovld __cnfn convert_int4_rtp(short4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(short4); |
| int4 __ovld __cnfn convert_int4_rtn(short4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(short4); |
| int4 __ovld __cnfn convert_int4(short4); |
| int4 __ovld __cnfn convert_int4_sat(short4); |
| int4 __ovld __cnfn convert_int4_rte(ushort4); |
| int4 __ovld __cnfn convert_int4_sat_rte(ushort4); |
| int4 __ovld __cnfn convert_int4_rtz(ushort4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(ushort4); |
| int4 __ovld __cnfn convert_int4_rtp(ushort4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(ushort4); |
| int4 __ovld __cnfn convert_int4_rtn(ushort4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(ushort4); |
| int4 __ovld __cnfn convert_int4(ushort4); |
| int4 __ovld __cnfn convert_int4_sat(ushort4); |
| int4 __ovld __cnfn convert_int4_rte(int4); |
| int4 __ovld __cnfn convert_int4_sat_rte(int4); |
| int4 __ovld __cnfn convert_int4_rtz(int4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(int4); |
| int4 __ovld __cnfn convert_int4_rtp(int4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(int4); |
| int4 __ovld __cnfn convert_int4_rtn(int4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(int4); |
| int4 __ovld __cnfn convert_int4(int4); |
| int4 __ovld __cnfn convert_int4_sat(int4); |
| int4 __ovld __cnfn convert_int4_rte(uint4); |
| int4 __ovld __cnfn convert_int4_sat_rte(uint4); |
| int4 __ovld __cnfn convert_int4_rtz(uint4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(uint4); |
| int4 __ovld __cnfn convert_int4_rtp(uint4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(uint4); |
| int4 __ovld __cnfn convert_int4_rtn(uint4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(uint4); |
| int4 __ovld __cnfn convert_int4(uint4); |
| int4 __ovld __cnfn convert_int4_sat(uint4); |
| int4 __ovld __cnfn convert_int4_rte(long4); |
| int4 __ovld __cnfn convert_int4_sat_rte(long4); |
| int4 __ovld __cnfn convert_int4_rtz(long4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(long4); |
| int4 __ovld __cnfn convert_int4_rtp(long4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(long4); |
| int4 __ovld __cnfn convert_int4_rtn(long4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(long4); |
| int4 __ovld __cnfn convert_int4(long4); |
| int4 __ovld __cnfn convert_int4_sat(long4); |
| int4 __ovld __cnfn convert_int4_rte(ulong4); |
| int4 __ovld __cnfn convert_int4_sat_rte(ulong4); |
| int4 __ovld __cnfn convert_int4_rtz(ulong4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(ulong4); |
| int4 __ovld __cnfn convert_int4_rtp(ulong4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(ulong4); |
| int4 __ovld __cnfn convert_int4_rtn(ulong4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(ulong4); |
| int4 __ovld __cnfn convert_int4(ulong4); |
| int4 __ovld __cnfn convert_int4_sat(ulong4); |
| int4 __ovld __cnfn convert_int4_rte(float4); |
| int4 __ovld __cnfn convert_int4_sat_rte(float4); |
| int4 __ovld __cnfn convert_int4_rtz(float4); |
| int4 __ovld __cnfn convert_int4_sat_rtz(float4); |
| int4 __ovld __cnfn convert_int4_rtp(float4); |
| int4 __ovld __cnfn convert_int4_sat_rtp(float4); |
| int4 __ovld __cnfn convert_int4_rtn(float4); |
| int4 __ovld __cnfn convert_int4_sat_rtn(float4); |
| int4 __ovld __cnfn convert_int4(float4); |
| int4 __ovld __cnfn convert_int4_sat(float4); |
| uint4 __ovld __cnfn convert_uint4_rte(char4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(char4); |
| uint4 __ovld __cnfn convert_uint4_rtz(char4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(char4); |
| uint4 __ovld __cnfn convert_uint4_rtp(char4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(char4); |
| uint4 __ovld __cnfn convert_uint4_rtn(char4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(char4); |
| uint4 __ovld __cnfn convert_uint4(char4); |
| uint4 __ovld __cnfn convert_uint4_sat(char4); |
| uint4 __ovld __cnfn convert_uint4_rte(uchar4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(uchar4); |
| uint4 __ovld __cnfn convert_uint4_rtz(uchar4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(uchar4); |
| uint4 __ovld __cnfn convert_uint4_rtp(uchar4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(uchar4); |
| uint4 __ovld __cnfn convert_uint4_rtn(uchar4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(uchar4); |
| uint4 __ovld __cnfn convert_uint4(uchar4); |
| uint4 __ovld __cnfn convert_uint4_sat(uchar4); |
| uint4 __ovld __cnfn convert_uint4_rte(short4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(short4); |
| uint4 __ovld __cnfn convert_uint4_rtz(short4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(short4); |
| uint4 __ovld __cnfn convert_uint4_rtp(short4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(short4); |
| uint4 __ovld __cnfn convert_uint4_rtn(short4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(short4); |
| uint4 __ovld __cnfn convert_uint4(short4); |
| uint4 __ovld __cnfn convert_uint4_sat(short4); |
| uint4 __ovld __cnfn convert_uint4_rte(ushort4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(ushort4); |
| uint4 __ovld __cnfn convert_uint4_rtz(ushort4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(ushort4); |
| uint4 __ovld __cnfn convert_uint4_rtp(ushort4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(ushort4); |
| uint4 __ovld __cnfn convert_uint4_rtn(ushort4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(ushort4); |
| uint4 __ovld __cnfn convert_uint4(ushort4); |
| uint4 __ovld __cnfn convert_uint4_sat(ushort4); |
| uint4 __ovld __cnfn convert_uint4_rte(int4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(int4); |
| uint4 __ovld __cnfn convert_uint4_rtz(int4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(int4); |
| uint4 __ovld __cnfn convert_uint4_rtp(int4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(int4); |
| uint4 __ovld __cnfn convert_uint4_rtn(int4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(int4); |
| uint4 __ovld __cnfn convert_uint4(int4); |
| uint4 __ovld __cnfn convert_uint4_sat(int4); |
| uint4 __ovld __cnfn convert_uint4_rte(uint4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(uint4); |
| uint4 __ovld __cnfn convert_uint4_rtz(uint4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(uint4); |
| uint4 __ovld __cnfn convert_uint4_rtp(uint4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(uint4); |
| uint4 __ovld __cnfn convert_uint4_rtn(uint4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(uint4); |
| uint4 __ovld __cnfn convert_uint4(uint4); |
| uint4 __ovld __cnfn convert_uint4_sat(uint4); |
| uint4 __ovld __cnfn convert_uint4_rte(long4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(long4); |
| uint4 __ovld __cnfn convert_uint4_rtz(long4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(long4); |
| uint4 __ovld __cnfn convert_uint4_rtp(long4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(long4); |
| uint4 __ovld __cnfn convert_uint4_rtn(long4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(long4); |
| uint4 __ovld __cnfn convert_uint4(long4); |
| uint4 __ovld __cnfn convert_uint4_sat(long4); |
| uint4 __ovld __cnfn convert_uint4_rte(ulong4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(ulong4); |
| uint4 __ovld __cnfn convert_uint4_rtz(ulong4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(ulong4); |
| uint4 __ovld __cnfn convert_uint4_rtp(ulong4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(ulong4); |
| uint4 __ovld __cnfn convert_uint4_rtn(ulong4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(ulong4); |
| uint4 __ovld __cnfn convert_uint4(ulong4); |
| uint4 __ovld __cnfn convert_uint4_sat(ulong4); |
| uint4 __ovld __cnfn convert_uint4_rte(float4); |
| uint4 __ovld __cnfn convert_uint4_sat_rte(float4); |
| uint4 __ovld __cnfn convert_uint4_rtz(float4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtz(float4); |
| uint4 __ovld __cnfn convert_uint4_rtp(float4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtp(float4); |
| uint4 __ovld __cnfn convert_uint4_rtn(float4); |
| uint4 __ovld __cnfn convert_uint4_sat_rtn(float4); |
| uint4 __ovld __cnfn convert_uint4(float4); |
| uint4 __ovld __cnfn convert_uint4_sat(float4); |
| long4 __ovld __cnfn convert_long4_rte(char4); |
| long4 __ovld __cnfn convert_long4_sat_rte(char4); |
| long4 __ovld __cnfn convert_long4_rtz(char4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(char4); |
| long4 __ovld __cnfn convert_long4_rtp(char4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(char4); |
| long4 __ovld __cnfn convert_long4_rtn(char4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(char4); |
| long4 __ovld __cnfn convert_long4(char4); |
| long4 __ovld __cnfn convert_long4_sat(char4); |
| long4 __ovld __cnfn convert_long4_rte(uchar4); |
| long4 __ovld __cnfn convert_long4_sat_rte(uchar4); |
| long4 __ovld __cnfn convert_long4_rtz(uchar4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(uchar4); |
| long4 __ovld __cnfn convert_long4_rtp(uchar4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(uchar4); |
| long4 __ovld __cnfn convert_long4_rtn(uchar4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(uchar4); |
| long4 __ovld __cnfn convert_long4(uchar4); |
| long4 __ovld __cnfn convert_long4_sat(uchar4); |
| long4 __ovld __cnfn convert_long4_rte(short4); |
| long4 __ovld __cnfn convert_long4_sat_rte(short4); |
| long4 __ovld __cnfn convert_long4_rtz(short4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(short4); |
| long4 __ovld __cnfn convert_long4_rtp(short4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(short4); |
| long4 __ovld __cnfn convert_long4_rtn(short4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(short4); |
| long4 __ovld __cnfn convert_long4(short4); |
| long4 __ovld __cnfn convert_long4_sat(short4); |
| long4 __ovld __cnfn convert_long4_rte(ushort4); |
| long4 __ovld __cnfn convert_long4_sat_rte(ushort4); |
| long4 __ovld __cnfn convert_long4_rtz(ushort4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(ushort4); |
| long4 __ovld __cnfn convert_long4_rtp(ushort4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(ushort4); |
| long4 __ovld __cnfn convert_long4_rtn(ushort4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(ushort4); |
| long4 __ovld __cnfn convert_long4(ushort4); |
| long4 __ovld __cnfn convert_long4_sat(ushort4); |
| long4 __ovld __cnfn convert_long4_rte(int4); |
| long4 __ovld __cnfn convert_long4_sat_rte(int4); |
| long4 __ovld __cnfn convert_long4_rtz(int4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(int4); |
| long4 __ovld __cnfn convert_long4_rtp(int4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(int4); |
| long4 __ovld __cnfn convert_long4_rtn(int4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(int4); |
| long4 __ovld __cnfn convert_long4(int4); |
| long4 __ovld __cnfn convert_long4_sat(int4); |
| long4 __ovld __cnfn convert_long4_rte(uint4); |
| long4 __ovld __cnfn convert_long4_sat_rte(uint4); |
| long4 __ovld __cnfn convert_long4_rtz(uint4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(uint4); |
| long4 __ovld __cnfn convert_long4_rtp(uint4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(uint4); |
| long4 __ovld __cnfn convert_long4_rtn(uint4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(uint4); |
| long4 __ovld __cnfn convert_long4(uint4); |
| long4 __ovld __cnfn convert_long4_sat(uint4); |
| long4 __ovld __cnfn convert_long4_rte(long4); |
| long4 __ovld __cnfn convert_long4_sat_rte(long4); |
| long4 __ovld __cnfn convert_long4_rtz(long4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(long4); |
| long4 __ovld __cnfn convert_long4_rtp(long4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(long4); |
| long4 __ovld __cnfn convert_long4_rtn(long4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(long4); |
| long4 __ovld __cnfn convert_long4(long4); |
| long4 __ovld __cnfn convert_long4_sat(long4); |
| long4 __ovld __cnfn convert_long4_rte(ulong4); |
| long4 __ovld __cnfn convert_long4_sat_rte(ulong4); |
| long4 __ovld __cnfn convert_long4_rtz(ulong4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(ulong4); |
| long4 __ovld __cnfn convert_long4_rtp(ulong4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(ulong4); |
| long4 __ovld __cnfn convert_long4_rtn(ulong4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(ulong4); |
| long4 __ovld __cnfn convert_long4(ulong4); |
| long4 __ovld __cnfn convert_long4_sat(ulong4); |
| long4 __ovld __cnfn convert_long4_rte(float4); |
| long4 __ovld __cnfn convert_long4_sat_rte(float4); |
| long4 __ovld __cnfn convert_long4_rtz(float4); |
| long4 __ovld __cnfn convert_long4_sat_rtz(float4); |
| long4 __ovld __cnfn convert_long4_rtp(float4); |
| long4 __ovld __cnfn convert_long4_sat_rtp(float4); |
| long4 __ovld __cnfn convert_long4_rtn(float4); |
| long4 __ovld __cnfn convert_long4_sat_rtn(float4); |
| long4 __ovld __cnfn convert_long4(float4); |
| long4 __ovld __cnfn convert_long4_sat(float4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(char4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(char4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(char4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(char4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(char4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(char4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(char4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(char4); |
| ulong4 __ovld __cnfn convert_ulong4(char4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(char4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(uchar4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(short4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(short4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(short4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(short4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(short4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(short4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(short4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(short4); |
| ulong4 __ovld __cnfn convert_ulong4(short4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(short4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(ushort4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(int4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(int4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(int4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(int4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(int4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(int4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(int4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(int4); |
| ulong4 __ovld __cnfn convert_ulong4(int4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(int4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(uint4); |
| ulong4 __ovld __cnfn convert_ulong4(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(uint4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(long4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(long4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(long4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(long4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(long4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(long4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(long4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(long4); |
| ulong4 __ovld __cnfn convert_ulong4(long4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(long4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(ulong4); |
| ulong4 __ovld __cnfn convert_ulong4_rte(float4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rte(float4); |
| ulong4 __ovld __cnfn convert_ulong4_rtz(float4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtz(float4); |
| ulong4 __ovld __cnfn convert_ulong4_rtp(float4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtp(float4); |
| ulong4 __ovld __cnfn convert_ulong4_rtn(float4); |
| ulong4 __ovld __cnfn convert_ulong4_sat_rtn(float4); |
| ulong4 __ovld __cnfn convert_ulong4(float4); |
| ulong4 __ovld __cnfn convert_ulong4_sat(float4); |
| float4 __ovld __cnfn convert_float4_rte(char4); |
| float4 __ovld __cnfn convert_float4_rtz(char4); |
| float4 __ovld __cnfn convert_float4_rtp(char4); |
| float4 __ovld __cnfn convert_float4_rtn(char4); |
| float4 __ovld __cnfn convert_float4(char4); |
| float4 __ovld __cnfn convert_float4_rte(uchar4); |
| float4 __ovld __cnfn convert_float4_rtz(uchar4); |
| float4 __ovld __cnfn convert_float4_rtp(uchar4); |
| float4 __ovld __cnfn convert_float4_rtn(uchar4); |
| float4 __ovld __cnfn convert_float4(uchar4); |
| float4 __ovld __cnfn convert_float4_rte(short4); |
| float4 __ovld __cnfn convert_float4_rtz(short4); |
| float4 __ovld __cnfn convert_float4_rtp(short4); |
| float4 __ovld __cnfn convert_float4_rtn(short4); |
| float4 __ovld __cnfn convert_float4(short4); |
| float4 __ovld __cnfn convert_float4_rte(ushort4); |
| float4 __ovld __cnfn convert_float4_rtz(ushort4); |
| float4 __ovld __cnfn convert_float4_rtp(ushort4); |
| float4 __ovld __cnfn convert_float4_rtn(ushort4); |
| float4 __ovld __cnfn convert_float4(ushort4); |
| float4 __ovld __cnfn convert_float4_rte(int4); |
| float4 __ovld __cnfn convert_float4_rtz(int4); |
| float4 __ovld __cnfn convert_float4_rtp(int4); |
| float4 __ovld __cnfn convert_float4_rtn(int4 |