etiss/opencl-c_8h_source.html

//===--- 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);

float4 __ovld __cnfn convert_float4(int4);

float4 __ovld __cnfn convert_float4_rte(uint4);

float4 __ovld __cnfn convert_float4_rtz(uint4);

float4 __ovld __cnfn convert_float4_rtp(uint4);

float4 __ovld __cnfn convert_float4_rtn(uint4);

float4 __ovld __cnfn convert_float4(uint4);

float4 __ovld __cnfn convert_float4_rte(long4);

float4 __ovld __cnfn convert_float4_rtz(long4);

float4 __ovld __cnfn convert_float4_rtp(long4);

float4 __ovld __cnfn convert_float4_rtn(long4);

float4 __ovld __cnfn convert_float4(long4);

float4 __ovld __cnfn convert_float4_rte(ulong4);

float4 __ovld __cnfn convert_float4_rtz(ulong4);

float4 __ovld __cnfn convert_float4_rtp(ulong4);

float4 __ovld __cnfn convert_float4_rtn(ulong4);

float4 __ovld __cnfn convert_float4(ulong4);

float4 __ovld __cnfn convert_float4_rte(float4);

float4 __ovld __cnfn convert_float4_rtz(float4);

float4 __ovld __cnfn convert_float4_rtp(float4);

float4 __ovld __cnfn convert_float4_rtn(float4);

float4 __ovld __cnfn convert_float4(float4);

char8 __ovld __cnfn convert_char8_rte(char8);

char8 __ovld __cnfn convert_char8_sat_rte(char8);

char8 __ovld __cnfn convert_char8_rtz(char8);

char8 __ovld __cnfn convert_char8_sat_rtz(char8);

char8 __ovld __cnfn convert_char8_rtp(char8);

char8 __ovld __cnfn convert_char8_sat_rtp(char8);

char8 __ovld __cnfn convert_char8_rtn(char8);

char8 __ovld __cnfn convert_char8_sat_rtn(char8);

char8 __ovld __cnfn convert_char8(char8);

char8 __ovld __cnfn convert_char8_sat(char8);

char8 __ovld __cnfn convert_char8_rte(uchar8);

char8 __ovld __cnfn convert_char8_sat_rte(uchar8);

char8 __ovld __cnfn convert_char8_rtz(uchar8);

char8 __ovld __cnfn convert_char8_sat_rtz(uchar8);

char8 __ovld __cnfn convert_char8_rtp(uchar8);

char8 __ovld __cnfn convert_char8_sat_rtp(uchar8);

char8 __ovld __cnfn convert_char8_rtn(uchar8);

char8 __ovld __cnfn convert_char8_sat_rtn(uchar8);

char8 __ovld __cnfn convert_char8(uchar8);

char8 __ovld __cnfn convert_char8_sat(uchar8);

char8 __ovld __cnfn convert_char8_rte(short8);

char8 __ovld __cnfn convert_char8_sat_rte(short8);

char8 __ovld __cnfn convert_char8_rtz(short8);

char8 __ovld __cnfn convert_char8_sat_rtz(short8);

char8 __ovld __cnfn convert_char8_rtp(short8);

char8 __ovld __cnfn convert_char8_sat_rtp(short8);

char8 __ovld __cnfn convert_char8_rtn(short8);

char8 __ovld __cnfn convert_char8_sat_rtn(short8);

char8 __ovld __cnfn convert_char8(short8);

char8 __ovld __cnfn convert_char8_sat(short8);

char8 __ovld __cnfn convert_char8_rte(ushort8);

char8 __ovld __cnfn convert_char8_sat_rte(ushort8);

char8 __ovld __cnfn convert_char8_rtz(ushort8);

char8 __ovld __cnfn convert_char8_sat_rtz(ushort8);

char8 __ovld __cnfn convert_char8_rtp(ushort8);

char8 __ovld __cnfn convert_char8_sat_rtp(ushort8);

char8 __ovld __cnfn convert_char8_rtn(ushort8);

char8 __ovld __cnfn convert_char8_sat_rtn(ushort8);

char8 __ovld __cnfn convert_char8(ushort8);

char8 __ovld __cnfn convert_char8_sat(ushort8);

char8 __ovld __cnfn convert_char8_rte(int8);

char8 __ovld __cnfn convert_char8_sat_rte(int8);

char8 __ovld __cnfn convert_char8_rtz(int8);

char8 __ovld __cnfn convert_char8_sat_rtz(int8);

char8 __ovld __cnfn convert_char8_rtp(int8);

char8 __ovld __cnfn convert_char8_sat_rtp(int8);

char8 __ovld __cnfn convert_char8_rtn(int8);

char8 __ovld __cnfn convert_char8_sat_rtn(int8);

char8 __ovld __cnfn convert_char8(int8);

char8 __ovld __cnfn convert_char8_sat(int8);

char8 __ovld __cnfn convert_char8_rte(uint8);

char8 __ovld __cnfn convert_char8_sat_rte(uint8);

char8 __ovld __cnfn convert_char8_rtz(uint8);

char8 __ovld __cnfn convert_char8_sat_rtz(uint8);

char8 __ovld __cnfn convert_char8_rtp(uint8);

char8 __ovld __cnfn convert_char8_sat_rtp(uint8);

char8 __ovld __cnfn convert_char8_rtn(uint8);

char8 __ovld __cnfn convert_char8_sat_rtn(uint8);

char8 __ovld __cnfn convert_char8(uint8);

char8 __ovld __cnfn convert_char8_sat(uint8);

char8 __ovld __cnfn convert_char8_rte(long8);

char8 __ovld __cnfn convert_char8_sat_rte(long8);

char8 __ovld __cnfn convert_char8_rtz(long8);

char8 __ovld __cnfn convert_char8_sat_rtz(long8);

char8 __ovld __cnfn convert_char8_rtp(long8);

char8 __ovld __cnfn convert_char8_sat_rtp(long8);

char8 __ovld __cnfn convert_char8_rtn(long8);

char8 __ovld __cnfn convert_char8_sat_rtn(long8);

char8 __ovld __cnfn convert_char8(long8);

char8 __ovld __cnfn convert_char8_sat(long8);

char8 __ovld __cnfn convert_char8_rte(ulong8);

char8 __ovld __cnfn convert_char8_sat_rte(ulong8);

char8 __ovld __cnfn convert_char8_rtz(ulong8);

char8 __ovld __cnfn convert_char8_sat_rtz(ulong8);

char8 __ovld __cnfn convert_char8_rtp(ulong8);

char8 __ovld __cnfn convert_char8_sat_rtp(ulong8);

char8 __ovld __cnfn convert_char8_rtn(ulong8);

char8 __ovld __cnfn convert_char8_sat_rtn(ulong8);

char8 __ovld __cnfn convert_char8(ulong8);

char8 __ovld __cnfn convert_char8_sat(ulong8);

char8 __ovld __cnfn convert_char8_rte(float8);

char8 __ovld __cnfn convert_char8_sat_rte(float8);

char8 __ovld __cnfn convert_char8_rtz(float8);

char8 __ovld __cnfn convert_char8_sat_rtz(float8);

char8 __ovld __cnfn convert_char8_rtp(float8);

char8 __ovld __cnfn convert_char8_sat_rtp(float8);

char8 __ovld __cnfn convert_char8_rtn(float8);

char8 __ovld __cnfn convert_char8_sat_rtn(float8);

char8 __ovld __cnfn convert_char8(float8);

char8 __ovld __cnfn convert_char8_sat(float8);

uchar8 __ovld __cnfn convert_uchar8_rte(char8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(char8);

uchar8 __ovld __cnfn convert_uchar8_rtz(char8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(char8);

uchar8 __ovld __cnfn convert_uchar8_rtp(char8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(char8);

uchar8 __ovld __cnfn convert_uchar8_rtn(char8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(char8);

uchar8 __ovld __cnfn convert_uchar8(char8);

uchar8 __ovld __cnfn convert_uchar8_sat(char8);

uchar8 __ovld __cnfn convert_uchar8_rte(uchar8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(uchar8);

uchar8 __ovld __cnfn convert_uchar8_rtz(uchar8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(uchar8);

uchar8 __ovld __cnfn convert_uchar8_rtp(uchar8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(uchar8);

uchar8 __ovld __cnfn convert_uchar8_rtn(uchar8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(uchar8);

uchar8 __ovld __cnfn convert_uchar8(uchar8);

uchar8 __ovld __cnfn convert_uchar8_sat(uchar8);

uchar8 __ovld __cnfn convert_uchar8_rte(short8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(short8);

uchar8 __ovld __cnfn convert_uchar8_rtz(short8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(short8);

uchar8 __ovld __cnfn convert_uchar8_rtp(short8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(short8);

uchar8 __ovld __cnfn convert_uchar8_rtn(short8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(short8);

uchar8 __ovld __cnfn convert_uchar8(short8);

uchar8 __ovld __cnfn convert_uchar8_sat(short8);

uchar8 __ovld __cnfn convert_uchar8_rte(ushort8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(ushort8);

uchar8 __ovld __cnfn convert_uchar8_rtz(ushort8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(ushort8);

uchar8 __ovld __cnfn convert_uchar8_rtp(ushort8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(ushort8);

uchar8 __ovld __cnfn convert_uchar8_rtn(ushort8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(ushort8);

uchar8 __ovld __cnfn convert_uchar8(ushort8);

uchar8 __ovld __cnfn convert_uchar8_sat(ushort8);

uchar8 __ovld __cnfn convert_uchar8_rte(int8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(int8);

uchar8 __ovld __cnfn convert_uchar8_rtz(int8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(int8);

uchar8 __ovld __cnfn convert_uchar8_rtp(int8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(int8);

uchar8 __ovld __cnfn convert_uchar8_rtn(int8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(int8);

uchar8 __ovld __cnfn convert_uchar8(int8);

uchar8 __ovld __cnfn convert_uchar8_sat(int8);

uchar8 __ovld __cnfn convert_uchar8_rte(uint8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(uint8);

uchar8 __ovld __cnfn convert_uchar8_rtz(uint8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(uint8);

uchar8 __ovld __cnfn convert_uchar8_rtp(uint8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(uint8);

uchar8 __ovld __cnfn convert_uchar8_rtn(uint8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(uint8);

uchar8 __ovld __cnfn convert_uchar8(uint8);

uchar8 __ovld __cnfn convert_uchar8_sat(uint8);

uchar8 __ovld __cnfn convert_uchar8_rte(long8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(long8);

uchar8 __ovld __cnfn convert_uchar8_rtz(long8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(long8);

uchar8 __ovld __cnfn convert_uchar8_rtp(long8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(long8);

uchar8 __ovld __cnfn convert_uchar8_rtn(long8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(long8);

uchar8 __ovld __cnfn convert_uchar8(long8);

uchar8 __ovld __cnfn convert_uchar8_sat(long8);

uchar8 __ovld __cnfn convert_uchar8_rte(ulong8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(ulong8);

uchar8 __ovld __cnfn convert_uchar8_rtz(ulong8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(ulong8);

uchar8 __ovld __cnfn convert_uchar8_rtp(ulong8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(ulong8);

uchar8 __ovld __cnfn convert_uchar8_rtn(ulong8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(ulong8);

uchar8 __ovld __cnfn convert_uchar8(ulong8);

uchar8 __ovld __cnfn convert_uchar8_sat(ulong8);

uchar8 __ovld __cnfn convert_uchar8_rte(float8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(float8);

uchar8 __ovld __cnfn convert_uchar8_rtz(float8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(float8);

uchar8 __ovld __cnfn convert_uchar8_rtp(float8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(float8);

uchar8 __ovld __cnfn convert_uchar8_rtn(float8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(float8);

uchar8 __ovld __cnfn convert_uchar8(float8);

uchar8 __ovld __cnfn convert_uchar8_sat(float8);

short8 __ovld __cnfn convert_short8_rte(char8);

short8 __ovld __cnfn convert_short8_sat_rte(char8);

short8 __ovld __cnfn convert_short8_rtz(char8);

short8 __ovld __cnfn convert_short8_sat_rtz(char8);

short8 __ovld __cnfn convert_short8_rtp(char8);

short8 __ovld __cnfn convert_short8_sat_rtp(char8);

short8 __ovld __cnfn convert_short8_rtn(char8);

short8 __ovld __cnfn convert_short8_sat_rtn(char8);

short8 __ovld __cnfn convert_short8(char8);

short8 __ovld __cnfn convert_short8_sat(char8);

short8 __ovld __cnfn convert_short8_rte(uchar8);

short8 __ovld __cnfn convert_short8_sat_rte(uchar8);

short8 __ovld __cnfn convert_short8_rtz(uchar8);

short8 __ovld __cnfn convert_short8_sat_rtz(uchar8);

short8 __ovld __cnfn convert_short8_rtp(uchar8);

short8 __ovld __cnfn convert_short8_sat_rtp(uchar8);

short8 __ovld __cnfn convert_short8_rtn(uchar8);

short8 __ovld __cnfn convert_short8_sat_rtn(uchar8);

short8 __ovld __cnfn convert_short8(uchar8);

short8 __ovld __cnfn convert_short8_sat(uchar8);

short8 __ovld __cnfn convert_short8_rte(short8);

short8 __ovld __cnfn convert_short8_sat_rte(short8);

short8 __ovld __cnfn convert_short8_rtz(short8);

short8 __ovld __cnfn convert_short8_sat_rtz(short8);

short8 __ovld __cnfn convert_short8_rtp(short8);

short8 __ovld __cnfn convert_short8_sat_rtp(short8);

short8 __ovld __cnfn convert_short8_rtn(short8);

short8 __ovld __cnfn convert_short8_sat_rtn(short8);

short8 __ovld __cnfn convert_short8(short8);

short8 __ovld __cnfn convert_short8_sat(short8);

short8 __ovld __cnfn convert_short8_rte(ushort8);

short8 __ovld __cnfn convert_short8_sat_rte(ushort8);

short8 __ovld __cnfn convert_short8_rtz(ushort8);

short8 __ovld __cnfn convert_short8_sat_rtz(ushort8);

short8 __ovld __cnfn convert_short8_rtp(ushort8);

short8 __ovld __cnfn convert_short8_sat_rtp(ushort8);

short8 __ovld __cnfn convert_short8_rtn(ushort8);

short8 __ovld __cnfn convert_short8_sat_rtn(ushort8);

short8 __ovld __cnfn convert_short8(ushort8);

short8 __ovld __cnfn convert_short8_sat(ushort8);

short8 __ovld __cnfn convert_short8_rte(int8);

short8 __ovld __cnfn convert_short8_sat_rte(int8);

short8 __ovld __cnfn convert_short8_rtz(int8);

short8 __ovld __cnfn convert_short8_sat_rtz(int8);

short8 __ovld __cnfn convert_short8_rtp(int8);

short8 __ovld __cnfn convert_short8_sat_rtp(int8);

short8 __ovld __cnfn convert_short8_rtn(int8);

short8 __ovld __cnfn convert_short8_sat_rtn(int8);

short8 __ovld __cnfn convert_short8(int8);

short8 __ovld __cnfn convert_short8_sat(int8);

short8 __ovld __cnfn convert_short8_rte(uint8);

short8 __ovld __cnfn convert_short8_sat_rte(uint8);

short8 __ovld __cnfn convert_short8_rtz(uint8);

short8 __ovld __cnfn convert_short8_sat_rtz(uint8);

short8 __ovld __cnfn convert_short8_rtp(uint8);

short8 __ovld __cnfn convert_short8_sat_rtp(uint8);

short8 __ovld __cnfn convert_short8_rtn(uint8);

short8 __ovld __cnfn convert_short8_sat_rtn(uint8);

short8 __ovld __cnfn convert_short8(uint8);

short8 __ovld __cnfn convert_short8_sat(uint8);

short8 __ovld __cnfn convert_short8_rte(long8);

short8 __ovld __cnfn convert_short8_sat_rte(long8);

short8 __ovld __cnfn convert_short8_rtz(long8);

short8 __ovld __cnfn convert_short8_sat_rtz(long8);

short8 __ovld __cnfn convert_short8_rtp(long8);

short8 __ovld __cnfn convert_short8_sat_rtp(long8);

short8 __ovld __cnfn convert_short8_rtn(long8);

short8 __ovld __cnfn convert_short8_sat_rtn(long8);

short8 __ovld __cnfn convert_short8(long8);

short8 __ovld __cnfn convert_short8_sat(long8);

short8 __ovld __cnfn convert_short8_rte(ulong8);

short8 __ovld __cnfn convert_short8_sat_rte(ulong8);

short8 __ovld __cnfn convert_short8_rtz(ulong8);

short8 __ovld __cnfn convert_short8_sat_rtz(ulong8);

short8 __ovld __cnfn convert_short8_rtp(ulong8);

short8 __ovld __cnfn convert_short8_sat_rtp(ulong8);

short8 __ovld __cnfn convert_short8_rtn(ulong8);

short8 __ovld __cnfn convert_short8_sat_rtn(ulong8);

short8 __ovld __cnfn convert_short8(ulong8);

short8 __ovld __cnfn convert_short8_sat(ulong8);

short8 __ovld __cnfn convert_short8_rte(float8);

short8 __ovld __cnfn convert_short8_sat_rte(float8);

short8 __ovld __cnfn convert_short8_rtz(float8);

short8 __ovld __cnfn convert_short8_sat_rtz(float8);

short8 __ovld __cnfn convert_short8_rtp(float8);

short8 __ovld __cnfn convert_short8_sat_rtp(float8);

short8 __ovld __cnfn convert_short8_rtn(float8);

short8 __ovld __cnfn convert_short8_sat_rtn(float8);

short8 __ovld __cnfn convert_short8(float8);

short8 __ovld __cnfn convert_short8_sat(float8);

ushort8 __ovld __cnfn convert_ushort8_rte(char8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(char8);

ushort8 __ovld __cnfn convert_ushort8_rtz(char8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(char8);

ushort8 __ovld __cnfn convert_ushort8_rtp(char8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(char8);

ushort8 __ovld __cnfn convert_ushort8_rtn(char8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(char8);

ushort8 __ovld __cnfn convert_ushort8(char8);

ushort8 __ovld __cnfn convert_ushort8_sat(char8);

ushort8 __ovld __cnfn convert_ushort8_rte(uchar8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(uchar8);

ushort8 __ovld __cnfn convert_ushort8_rtz(uchar8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(uchar8);

ushort8 __ovld __cnfn convert_ushort8_rtp(uchar8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(uchar8);

ushort8 __ovld __cnfn convert_ushort8_rtn(uchar8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(uchar8);

ushort8 __ovld __cnfn convert_ushort8(uchar8);

ushort8 __ovld __cnfn convert_ushort8_sat(uchar8);

ushort8 __ovld __cnfn convert_ushort8_rte(short8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(short8);

ushort8 __ovld __cnfn convert_ushort8_rtz(short8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(short8);

ushort8 __ovld __cnfn convert_ushort8_rtp(short8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(short8);

ushort8 __ovld __cnfn convert_ushort8_rtn(short8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(short8);

ushort8 __ovld __cnfn convert_ushort8(short8);

ushort8 __ovld __cnfn convert_ushort8_sat(short8);

ushort8 __ovld __cnfn convert_ushort8_rte(ushort8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(ushort8);

ushort8 __ovld __cnfn convert_ushort8_rtz(ushort8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(ushort8);

ushort8 __ovld __cnfn convert_ushort8_rtp(ushort8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(ushort8);

ushort8 __ovld __cnfn convert_ushort8_rtn(ushort8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(ushort8);

ushort8 __ovld __cnfn convert_ushort8(ushort8);

ushort8 __ovld __cnfn convert_ushort8_sat(ushort8);

ushort8 __ovld __cnfn convert_ushort8_rte(int8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(int8);

ushort8 __ovld __cnfn convert_ushort8_rtz(int8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(int8);

ushort8 __ovld __cnfn convert_ushort8_rtp(int8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(int8);

ushort8 __ovld __cnfn convert_ushort8_rtn(int8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(int8);

ushort8 __ovld __cnfn convert_ushort8(int8);

ushort8 __ovld __cnfn convert_ushort8_sat(int8);

ushort8 __ovld __cnfn convert_ushort8_rte(uint8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(uint8);

ushort8 __ovld __cnfn convert_ushort8_rtz(uint8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(uint8);

ushort8 __ovld __cnfn convert_ushort8_rtp(uint8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(uint8);

ushort8 __ovld __cnfn convert_ushort8_rtn(uint8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(uint8);

ushort8 __ovld __cnfn convert_ushort8(uint8);

ushort8 __ovld __cnfn convert_ushort8_sat(uint8);

ushort8 __ovld __cnfn convert_ushort8_rte(long8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(long8);

ushort8 __ovld __cnfn convert_ushort8_rtz(long8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(long8);

ushort8 __ovld __cnfn convert_ushort8_rtp(long8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(long8);

ushort8 __ovld __cnfn convert_ushort8_rtn(long8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(long8);

ushort8 __ovld __cnfn convert_ushort8(long8);

ushort8 __ovld __cnfn convert_ushort8_sat(long8);

ushort8 __ovld __cnfn convert_ushort8_rte(ulong8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(ulong8);

ushort8 __ovld __cnfn convert_ushort8_rtz(ulong8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(ulong8);

ushort8 __ovld __cnfn convert_ushort8_rtp(ulong8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(ulong8);

ushort8 __ovld __cnfn convert_ushort8_rtn(ulong8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(ulong8);

ushort8 __ovld __cnfn convert_ushort8(ulong8);

ushort8 __ovld __cnfn convert_ushort8_sat(ulong8);

ushort8 __ovld __cnfn convert_ushort8_rte(float8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(float8);

ushort8 __ovld __cnfn convert_ushort8_rtz(float8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(float8);

ushort8 __ovld __cnfn convert_ushort8_rtp(float8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(float8);

ushort8 __ovld __cnfn convert_ushort8_rtn(float8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(float8);

ushort8 __ovld __cnfn convert_ushort8(float8);

ushort8 __ovld __cnfn convert_ushort8_sat(float8);

int8 __ovld __cnfn convert_int8_rte(char8);

int8 __ovld __cnfn convert_int8_sat_rte(char8);

int8 __ovld __cnfn convert_int8_rtz(char8);

int8 __ovld __cnfn convert_int8_sat_rtz(char8);

int8 __ovld __cnfn convert_int8_rtp(char8);

int8 __ovld __cnfn convert_int8_sat_rtp(char8);

int8 __ovld __cnfn convert_int8_rtn(char8);

int8 __ovld __cnfn convert_int8_sat_rtn(char8);

int8 __ovld __cnfn convert_int8(char8);

int8 __ovld __cnfn convert_int8_sat(char8);

int8 __ovld __cnfn convert_int8_rte(uchar8);

int8 __ovld __cnfn convert_int8_sat_rte(uchar8);

int8 __ovld __cnfn convert_int8_rtz(uchar8);

int8 __ovld __cnfn convert_int8_sat_rtz(uchar8);

int8 __ovld __cnfn convert_int8_rtp(uchar8);

int8 __ovld __cnfn convert_int8_sat_rtp(uchar8);

int8 __ovld __cnfn convert_int8_rtn(uchar8);

int8 __ovld __cnfn convert_int8_sat_rtn(uchar8);

int8 __ovld __cnfn convert_int8(uchar8);

int8 __ovld __cnfn convert_int8_sat(uchar8);

int8 __ovld __cnfn convert_int8_rte(short8);

int8 __ovld __cnfn convert_int8_sat_rte(short8);

int8 __ovld __cnfn convert_int8_rtz(short8);

int8 __ovld __cnfn convert_int8_sat_rtz(short8);

int8 __ovld __cnfn convert_int8_rtp(short8);

int8 __ovld __cnfn convert_int8_sat_rtp(short8);

int8 __ovld __cnfn convert_int8_rtn(short8);

int8 __ovld __cnfn convert_int8_sat_rtn(short8);

int8 __ovld __cnfn convert_int8(short8);

int8 __ovld __cnfn convert_int8_sat(short8);

int8 __ovld __cnfn convert_int8_rte(ushort8);

int8 __ovld __cnfn convert_int8_sat_rte(ushort8);

int8 __ovld __cnfn convert_int8_rtz(ushort8);

int8 __ovld __cnfn convert_int8_sat_rtz(ushort8);

int8 __ovld __cnfn convert_int8_rtp(ushort8);

int8 __ovld __cnfn convert_int8_sat_rtp(ushort8);

int8 __ovld __cnfn convert_int8_rtn(ushort8);

int8 __ovld __cnfn convert_int8_sat_rtn(ushort8);

int8 __ovld __cnfn convert_int8(ushort8);

int8 __ovld __cnfn convert_int8_sat(ushort8);

int8 __ovld __cnfn convert_int8_rte(int8);

int8 __ovld __cnfn convert_int8_sat_rte(int8);

int8 __ovld __cnfn convert_int8_rtz(int8);

int8 __ovld __cnfn convert_int8_sat_rtz(int8);

int8 __ovld __cnfn convert_int8_rtp(int8);

int8 __ovld __cnfn convert_int8_sat_rtp(int8);

int8 __ovld __cnfn convert_int8_rtn(int8);

int8 __ovld __cnfn convert_int8_sat_rtn(int8);

int8 __ovld __cnfn convert_int8(int8);

int8 __ovld __cnfn convert_int8_sat(int8);

int8 __ovld __cnfn convert_int8_rte(uint8);

int8 __ovld __cnfn convert_int8_sat_rte(uint8);

int8 __ovld __cnfn convert_int8_rtz(uint8);

int8 __ovld __cnfn convert_int8_sat_rtz(uint8);

int8 __ovld __cnfn convert_int8_rtp(uint8);

int8 __ovld __cnfn convert_int8_sat_rtp(uint8);

int8 __ovld __cnfn convert_int8_rtn(uint8);

int8 __ovld __cnfn convert_int8_sat_rtn(uint8);

int8 __ovld __cnfn convert_int8(uint8);

int8 __ovld __cnfn convert_int8_sat(uint8);

int8 __ovld __cnfn convert_int8_rte(long8);

int8 __ovld __cnfn convert_int8_sat_rte(long8);

int8 __ovld __cnfn convert_int8_rtz(long8);

int8 __ovld __cnfn convert_int8_sat_rtz(long8);

int8 __ovld __cnfn convert_int8_rtp(long8);

int8 __ovld __cnfn convert_int8_sat_rtp(long8);

int8 __ovld __cnfn convert_int8_rtn(long8);

int8 __ovld __cnfn convert_int8_sat_rtn(long8);

int8 __ovld __cnfn convert_int8(long8);

int8 __ovld __cnfn convert_int8_sat(long8);

int8 __ovld __cnfn convert_int8_rte(ulong8);

int8 __ovld __cnfn convert_int8_sat_rte(ulong8);

int8 __ovld __cnfn convert_int8_rtz(ulong8);

int8 __ovld __cnfn convert_int8_sat_rtz(ulong8);

int8 __ovld __cnfn convert_int8_rtp(ulong8);

int8 __ovld __cnfn convert_int8_sat_rtp(ulong8);

int8 __ovld __cnfn convert_int8_rtn(ulong8);

int8 __ovld __cnfn convert_int8_sat_rtn(ulong8);

int8 __ovld __cnfn convert_int8(ulong8);

int8 __ovld __cnfn convert_int8_sat(ulong8);

int8 __ovld __cnfn convert_int8_rte(float8);

int8 __ovld __cnfn convert_int8_sat_rte(float8);

int8 __ovld __cnfn convert_int8_rtz(float8);

int8 __ovld __cnfn convert_int8_sat_rtz(float8);

int8 __ovld __cnfn convert_int8_rtp(float8);

int8 __ovld __cnfn convert_int8_sat_rtp(float8);

int8 __ovld __cnfn convert_int8_rtn(float8);

int8 __ovld __cnfn convert_int8_sat_rtn(float8);

int8 __ovld __cnfn convert_int8(float8);

int8 __ovld __cnfn convert_int8_sat(float8);

uint8 __ovld __cnfn convert_uint8_rte(char8);

uint8 __ovld __cnfn convert_uint8_sat_rte(char8);

uint8 __ovld __cnfn convert_uint8_rtz(char8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(char8);

uint8 __ovld __cnfn convert_uint8_rtp(char8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(char8);

uint8 __ovld __cnfn convert_uint8_rtn(char8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(char8);

uint8 __ovld __cnfn convert_uint8(char8);

uint8 __ovld __cnfn convert_uint8_sat(char8);

uint8 __ovld __cnfn convert_uint8_rte(uchar8);

uint8 __ovld __cnfn convert_uint8_sat_rte(uchar8);

uint8 __ovld __cnfn convert_uint8_rtz(uchar8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(uchar8);

uint8 __ovld __cnfn convert_uint8_rtp(uchar8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(uchar8);

uint8 __ovld __cnfn convert_uint8_rtn(uchar8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(uchar8);

uint8 __ovld __cnfn convert_uint8(uchar8);

uint8 __ovld __cnfn convert_uint8_sat(uchar8);

uint8 __ovld __cnfn convert_uint8_rte(short8);

uint8 __ovld __cnfn convert_uint8_sat_rte(short8);

uint8 __ovld __cnfn convert_uint8_rtz(short8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(short8);

uint8 __ovld __cnfn convert_uint8_rtp(short8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(short8);

uint8 __ovld __cnfn convert_uint8_rtn(short8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(short8);

uint8 __ovld __cnfn convert_uint8(short8);

uint8 __ovld __cnfn convert_uint8_sat(short8);

uint8 __ovld __cnfn convert_uint8_rte(ushort8);

uint8 __ovld __cnfn convert_uint8_sat_rte(ushort8);

uint8 __ovld __cnfn convert_uint8_rtz(ushort8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(ushort8);

uint8 __ovld __cnfn convert_uint8_rtp(ushort8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(ushort8);

uint8 __ovld __cnfn convert_uint8_rtn(ushort8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(ushort8);

uint8 __ovld __cnfn convert_uint8(ushort8);

uint8 __ovld __cnfn convert_uint8_sat(ushort8);

uint8 __ovld __cnfn convert_uint8_rte(int8);

uint8 __ovld __cnfn convert_uint8_sat_rte(int8);

uint8 __ovld __cnfn convert_uint8_rtz(int8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(int8);

uint8 __ovld __cnfn convert_uint8_rtp(int8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(int8);

uint8 __ovld __cnfn convert_uint8_rtn(int8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(int8);

uint8 __ovld __cnfn convert_uint8(int8);

uint8 __ovld __cnfn convert_uint8_sat(int8);

uint8 __ovld __cnfn convert_uint8_rte(uint8);

uint8 __ovld __cnfn convert_uint8_sat_rte(uint8);

uint8 __ovld __cnfn convert_uint8_rtz(uint8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(uint8);

uint8 __ovld __cnfn convert_uint8_rtp(uint8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(uint8);

uint8 __ovld __cnfn convert_uint8_rtn(uint8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(uint8);

uint8 __ovld __cnfn convert_uint8(uint8);

uint8 __ovld __cnfn convert_uint8_sat(uint8);

uint8 __ovld __cnfn convert_uint8_rte(long8);

uint8 __ovld __cnfn convert_uint8_sat_rte(long8);

uint8 __ovld __cnfn convert_uint8_rtz(long8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(long8);

uint8 __ovld __cnfn convert_uint8_rtp(long8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(long8);

uint8 __ovld __cnfn convert_uint8_rtn(long8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(long8);

uint8 __ovld __cnfn convert_uint8(long8);

uint8 __ovld __cnfn convert_uint8_sat(long8);

uint8 __ovld __cnfn convert_uint8_rte(ulong8);

uint8 __ovld __cnfn convert_uint8_sat_rte(ulong8);

uint8 __ovld __cnfn convert_uint8_rtz(ulong8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(ulong8);

uint8 __ovld __cnfn convert_uint8_rtp(ulong8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(ulong8);

uint8 __ovld __cnfn convert_uint8_rtn(ulong8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(ulong8);

uint8 __ovld __cnfn convert_uint8(ulong8);

uint8 __ovld __cnfn convert_uint8_sat(ulong8);

uint8 __ovld __cnfn convert_uint8_rte(float8);

uint8 __ovld __cnfn convert_uint8_sat_rte(float8);

uint8 __ovld __cnfn convert_uint8_rtz(float8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(float8);

uint8 __ovld __cnfn convert_uint8_rtp(float8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(float8);

uint8 __ovld __cnfn convert_uint8_rtn(float8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(float8);

uint8 __ovld __cnfn convert_uint8(float8);

uint8 __ovld __cnfn convert_uint8_sat(float8);

long8 __ovld __cnfn convert_long8_rte(char8);

long8 __ovld __cnfn convert_long8_sat_rte(char8);

long8 __ovld __cnfn convert_long8_rtz(char8);

long8 __ovld __cnfn convert_long8_sat_rtz(char8);

long8 __ovld __cnfn convert_long8_rtp(char8);

long8 __ovld __cnfn convert_long8_sat_rtp(char8);

long8 __ovld __cnfn convert_long8_rtn(char8);

long8 __ovld __cnfn convert_long8_sat_rtn(char8);

long8 __ovld __cnfn convert_long8(char8);

long8 __ovld __cnfn convert_long8_sat(char8);

long8 __ovld __cnfn convert_long8_rte(uchar8);

long8 __ovld __cnfn convert_long8_sat_rte(uchar8);

long8 __ovld __cnfn convert_long8_rtz(uchar8);

long8 __ovld __cnfn convert_long8_sat_rtz(uchar8);

long8 __ovld __cnfn convert_long8_rtp(uchar8);

long8 __ovld __cnfn convert_long8_sat_rtp(uchar8);

long8 __ovld __cnfn convert_long8_rtn(uchar8);

long8 __ovld __cnfn convert_long8_sat_rtn(uchar8);

long8 __ovld __cnfn convert_long8(uchar8);

long8 __ovld __cnfn convert_long8_sat(uchar8);

long8 __ovld __cnfn convert_long8_rte(short8);

long8 __ovld __cnfn convert_long8_sat_rte(short8);

long8 __ovld __cnfn convert_long8_rtz(short8);

long8 __ovld __cnfn convert_long8_sat_rtz(short8);

long8 __ovld __cnfn convert_long8_rtp(short8);

long8 __ovld __cnfn convert_long8_sat_rtp(short8);

long8 __ovld __cnfn convert_long8_rtn(short8);

long8 __ovld __cnfn convert_long8_sat_rtn(short8);

long8 __ovld __cnfn convert_long8(short8);

long8 __ovld __cnfn convert_long8_sat(short8);

long8 __ovld __cnfn convert_long8_rte(ushort8);

long8 __ovld __cnfn convert_long8_sat_rte(ushort8);

long8 __ovld __cnfn convert_long8_rtz(ushort8);

long8 __ovld __cnfn convert_long8_sat_rtz(ushort8);

long8 __ovld __cnfn convert_long8_rtp(ushort8);

long8 __ovld __cnfn convert_long8_sat_rtp(ushort8);

long8 __ovld __cnfn convert_long8_rtn(ushort8);

long8 __ovld __cnfn convert_long8_sat_rtn(ushort8);

long8 __ovld __cnfn convert_long8(ushort8);

long8 __ovld __cnfn convert_long8_sat(ushort8);

long8 __ovld __cnfn convert_long8_rte(int8);

long8 __ovld __cnfn convert_long8_sat_rte(int8);

long8 __ovld __cnfn convert_long8_rtz(int8);

long8 __ovld __cnfn convert_long8_sat_rtz(int8);

long8 __ovld __cnfn convert_long8_rtp(int8);

long8 __ovld __cnfn convert_long8_sat_rtp(int8);

long8 __ovld __cnfn convert_long8_rtn(int8);

long8 __ovld __cnfn convert_long8_sat_rtn(int8);

long8 __ovld __cnfn convert_long8(int8);

long8 __ovld __cnfn convert_long8_sat(int8);

long8 __ovld __cnfn convert_long8_rte(uint8);

long8 __ovld __cnfn convert_long8_sat_rte(uint8);

long8 __ovld __cnfn convert_long8_rtz(uint8);

long8 __ovld __cnfn convert_long8_sat_rtz(uint8);

long8 __ovld __cnfn convert_long8_rtp(uint8);

long8 __ovld __cnfn convert_long8_sat_rtp(uint8);

long8 __ovld __cnfn convert_long8_rtn(uint8);

long8 __ovld __cnfn convert_long8_sat_rtn(uint8);

long8 __ovld __cnfn convert_long8(uint8);

long8 __ovld __cnfn convert_long8_sat(uint8);

long8 __ovld __cnfn convert_long8_rte(long8);

long8 __ovld __cnfn convert_long8_sat_rte(long8);

long8 __ovld __cnfn convert_long8_rtz(long8);

long8 __ovld __cnfn convert_long8_sat_rtz(long8);

long8 __ovld __cnfn convert_long8_rtp(long8);

long8 __ovld __cnfn convert_long8_sat_rtp(long8);

long8 __ovld __cnfn convert_long8_rtn(long8);

long8 __ovld __cnfn convert_long8_sat_rtn(long8);

long8 __ovld __cnfn convert_long8(long8);

long8 __ovld __cnfn convert_long8_sat(long8);

long8 __ovld __cnfn convert_long8_rte(ulong8);

long8 __ovld __cnfn convert_long8_sat_rte(ulong8);

long8 __ovld __cnfn convert_long8_rtz(ulong8);

long8 __ovld __cnfn convert_long8_sat_rtz(ulong8);

long8 __ovld __cnfn convert_long8_rtp(ulong8);

long8 __ovld __cnfn convert_long8_sat_rtp(ulong8);

long8 __ovld __cnfn convert_long8_rtn(ulong8);

long8 __ovld __cnfn convert_long8_sat_rtn(ulong8);

long8 __ovld __cnfn convert_long8(ulong8);

long8 __ovld __cnfn convert_long8_sat(ulong8);

long8 __ovld __cnfn convert_long8_rte(float8);

long8 __ovld __cnfn convert_long8_sat_rte(float8);

long8 __ovld __cnfn convert_long8_rtz(float8);

long8 __ovld __cnfn convert_long8_sat_rtz(float8);

long8 __ovld __cnfn convert_long8_rtp(float8);

long8 __ovld __cnfn convert_long8_sat_rtp(float8);

long8 __ovld __cnfn convert_long8_rtn(float8);

long8 __ovld __cnfn convert_long8_sat_rtn(float8);

long8 __ovld __cnfn convert_long8(float8);

long8 __ovld __cnfn convert_long8_sat(float8);

ulong8 __ovld __cnfn convert_ulong8_rte(char8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(char8);

ulong8 __ovld __cnfn convert_ulong8_rtz(char8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(char8);

ulong8 __ovld __cnfn convert_ulong8_rtp(char8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(char8);

ulong8 __ovld __cnfn convert_ulong8_rtn(char8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(char8);

ulong8 __ovld __cnfn convert_ulong8(char8);

ulong8 __ovld __cnfn convert_ulong8_sat(char8);

ulong8 __ovld __cnfn convert_ulong8_rte(uchar8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(uchar8);

ulong8 __ovld __cnfn convert_ulong8_rtz(uchar8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(uchar8);

ulong8 __ovld __cnfn convert_ulong8_rtp(uchar8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(uchar8);

ulong8 __ovld __cnfn convert_ulong8_rtn(uchar8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(uchar8);

ulong8 __ovld __cnfn convert_ulong8(uchar8);

ulong8 __ovld __cnfn convert_ulong8_sat(uchar8);

ulong8 __ovld __cnfn convert_ulong8_rte(short8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(short8);

ulong8 __ovld __cnfn convert_ulong8_rtz(short8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(short8);

ulong8 __ovld __cnfn convert_ulong8_rtp(short8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(short8);

ulong8 __ovld __cnfn convert_ulong8_rtn(short8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(short8);

ulong8 __ovld __cnfn convert_ulong8(short8);

ulong8 __ovld __cnfn convert_ulong8_sat(short8);

ulong8 __ovld __cnfn convert_ulong8_rte(ushort8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(ushort8);

ulong8 __ovld __cnfn convert_ulong8_rtz(ushort8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(ushort8);

ulong8 __ovld __cnfn convert_ulong8_rtp(ushort8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(ushort8);

ulong8 __ovld __cnfn convert_ulong8_rtn(ushort8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(ushort8);

ulong8 __ovld __cnfn convert_ulong8(ushort8);

ulong8 __ovld __cnfn convert_ulong8_sat(ushort8);

ulong8 __ovld __cnfn convert_ulong8_rte(int8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(int8);

ulong8 __ovld __cnfn convert_ulong8_rtz(int8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(int8);

ulong8 __ovld __cnfn convert_ulong8_rtp(int8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(int8);

ulong8 __ovld __cnfn convert_ulong8_rtn(int8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(int8);

ulong8 __ovld __cnfn convert_ulong8(int8);

ulong8 __ovld __cnfn convert_ulong8_sat(int8);

ulong8 __ovld __cnfn convert_ulong8_rte(uint8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(uint8);

ulong8 __ovld __cnfn convert_ulong8_rtz(uint8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(uint8);

ulong8 __ovld __cnfn convert_ulong8_rtp(uint8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(uint8);

ulong8 __ovld __cnfn convert_ulong8_rtn(uint8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(uint8);

ulong8 __ovld __cnfn convert_ulong8(uint8);

ulong8 __ovld __cnfn convert_ulong8_sat(uint8);

ulong8 __ovld __cnfn convert_ulong8_rte(long8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(long8);

ulong8 __ovld __cnfn convert_ulong8_rtz(long8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(long8);

ulong8 __ovld __cnfn convert_ulong8_rtp(long8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(long8);

ulong8 __ovld __cnfn convert_ulong8_rtn(long8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(long8);

ulong8 __ovld __cnfn convert_ulong8(long8);

ulong8 __ovld __cnfn convert_ulong8_sat(long8);

ulong8 __ovld __cnfn convert_ulong8_rte(ulong8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(ulong8);

ulong8 __ovld __cnfn convert_ulong8_rtz(ulong8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(ulong8);

ulong8 __ovld __cnfn convert_ulong8_rtp(ulong8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(ulong8);

ulong8 __ovld __cnfn convert_ulong8_rtn(ulong8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(ulong8);

ulong8 __ovld __cnfn convert_ulong8(ulong8);

ulong8 __ovld __cnfn convert_ulong8_sat(ulong8);

ulong8 __ovld __cnfn convert_ulong8_rte(float8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(float8);

ulong8 __ovld __cnfn convert_ulong8_rtz(float8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(float8);

ulong8 __ovld __cnfn convert_ulong8_rtp(float8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(float8);

ulong8 __ovld __cnfn convert_ulong8_rtn(float8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(float8);

ulong8 __ovld __cnfn convert_ulong8(float8);

ulong8 __ovld __cnfn convert_ulong8_sat(float8);

float8 __ovld __cnfn convert_float8_rte(char8);

float8 __ovld __cnfn convert_float8_rtz(char8);

float8 __ovld __cnfn convert_float8_rtp(char8);

float8 __ovld __cnfn convert_float8_rtn(char8);

float8 __ovld __cnfn convert_float8(char8);

float8 __ovld __cnfn convert_float8_rte(uchar8);

float8 __ovld __cnfn convert_float8_rtz(uchar8);

float8 __ovld __cnfn convert_float8_rtp(uchar8);

float8 __ovld __cnfn convert_float8_rtn(uchar8);

float8 __ovld __cnfn convert_float8(uchar8);

float8 __ovld __cnfn convert_float8_rte(short8);

float8 __ovld __cnfn convert_float8_rtz(short8);

float8 __ovld __cnfn convert_float8_rtp(short8);

float8 __ovld __cnfn convert_float8_rtn(short8);

float8 __ovld __cnfn convert_float8(short8);

float8 __ovld __cnfn convert_float8_rte(ushort8);

float8 __ovld __cnfn convert_float8_rtz(ushort8);

float8 __ovld __cnfn convert_float8_rtp(ushort8);

float8 __ovld __cnfn convert_float8_rtn(ushort8);

float8 __ovld __cnfn convert_float8(ushort8);

float8 __ovld __cnfn convert_float8_rte(int8);

float8 __ovld __cnfn convert_float8_rtz(int8);

float8 __ovld __cnfn convert_float8_rtp(int8);

float8 __ovld __cnfn convert_float8_rtn(int8);

float8 __ovld __cnfn convert_float8(int8);

float8 __ovld __cnfn convert_float8_rte(uint8);

float8 __ovld __cnfn convert_float8_rtz(uint8);

float8 __ovld __cnfn convert_float8_rtp(uint8);

float8 __ovld __cnfn convert_float8_rtn(uint8);

float8 __ovld __cnfn convert_float8(uint8);

float8 __ovld __cnfn convert_float8_rte(long8);

float8 __ovld __cnfn convert_float8_rtz(long8);

float8 __ovld __cnfn convert_float8_rtp(long8);

float8 __ovld __cnfn convert_float8_rtn(long8);

float8 __ovld __cnfn convert_float8(long8);

float8 __ovld __cnfn convert_float8_rte(ulong8);

float8 __ovld __cnfn convert_float8_rtz(ulong8);

float8 __ovld __cnfn convert_float8_rtp(ulong8);

float8 __ovld __cnfn convert_float8_rtn(ulong8);

float8 __ovld __cnfn convert_float8(ulong8);

float8 __ovld __cnfn convert_float8_rte(float8);

float8 __ovld __cnfn convert_float8_rtz(float8);

float8 __ovld __cnfn convert_float8_rtp(float8);

float8 __ovld __cnfn convert_float8_rtn(float8);

float8 __ovld __cnfn convert_float8(float8);

char16 __ovld __cnfn convert_char16_rte(char16);

char16 __ovld __cnfn convert_char16_sat_rte(char16);

char16 __ovld __cnfn convert_char16_rtz(char16);

char16 __ovld __cnfn convert_char16_sat_rtz(char16);

char16 __ovld __cnfn convert_char16_rtp(char16);

char16 __ovld __cnfn convert_char16_sat_rtp(char16);

char16 __ovld __cnfn convert_char16_rtn(char16);

char16 __ovld __cnfn convert_char16_sat_rtn(char16);

char16 __ovld __cnfn convert_char16(char16);

char16 __ovld __cnfn convert_char16_sat(char16);

char16 __ovld __cnfn convert_char16_rte(uchar16);

char16 __ovld __cnfn convert_char16_sat_rte(uchar16);

char16 __ovld __cnfn convert_char16_rtz(uchar16);

char16 __ovld __cnfn convert_char16_sat_rtz(uchar16);

char16 __ovld __cnfn convert_char16_rtp(uchar16);

char16 __ovld __cnfn convert_char16_sat_rtp(uchar16);

char16 __ovld __cnfn convert_char16_rtn(uchar16);

char16 __ovld __cnfn convert_char16_sat_rtn(uchar16);

char16 __ovld __cnfn convert_char16(uchar16);

char16 __ovld __cnfn convert_char16_sat(uchar16);

char16 __ovld __cnfn convert_char16_rte(short16);

char16 __ovld __cnfn convert_char16_sat_rte(short16);

char16 __ovld __cnfn convert_char16_rtz(short16);

char16 __ovld __cnfn convert_char16_sat_rtz(short16);

char16 __ovld __cnfn convert_char16_rtp(short16);

char16 __ovld __cnfn convert_char16_sat_rtp(short16);

char16 __ovld __cnfn convert_char16_rtn(short16);

char16 __ovld __cnfn convert_char16_sat_rtn(short16);

char16 __ovld __cnfn convert_char16(short16);

char16 __ovld __cnfn convert_char16_sat(short16);

char16 __ovld __cnfn convert_char16_rte(ushort16);

char16 __ovld __cnfn convert_char16_sat_rte(ushort16);

char16 __ovld __cnfn convert_char16_rtz(ushort16);

char16 __ovld __cnfn convert_char16_sat_rtz(ushort16);

char16 __ovld __cnfn convert_char16_rtp(ushort16);

char16 __ovld __cnfn convert_char16_sat_rtp(ushort16);

char16 __ovld __cnfn convert_char16_rtn(ushort16);

char16 __ovld __cnfn convert_char16_sat_rtn(ushort16);

char16 __ovld __cnfn convert_char16(ushort16);

char16 __ovld __cnfn convert_char16_sat(ushort16);

char16 __ovld __cnfn convert_char16_rte(int16);

char16 __ovld __cnfn convert_char16_sat_rte(int16);

char16 __ovld __cnfn convert_char16_rtz(int16);

char16 __ovld __cnfn convert_char16_sat_rtz(int16);

char16 __ovld __cnfn convert_char16_rtp(int16);

char16 __ovld __cnfn convert_char16_sat_rtp(int16);

char16 __ovld __cnfn convert_char16_rtn(int16);

char16 __ovld __cnfn convert_char16_sat_rtn(int16);

char16 __ovld __cnfn convert_char16(int16);

char16 __ovld __cnfn convert_char16_sat(int16);

char16 __ovld __cnfn convert_char16_rte(uint16);

char16 __ovld __cnfn convert_char16_sat_rte(uint16);

char16 __ovld __cnfn convert_char16_rtz(uint16);

char16 __ovld __cnfn convert_char16_sat_rtz(uint16);

char16 __ovld __cnfn convert_char16_rtp(uint16);

char16 __ovld __cnfn convert_char16_sat_rtp(uint16);

char16 __ovld __cnfn convert_char16_rtn(uint16);

char16 __ovld __cnfn convert_char16_sat_rtn(uint16);

char16 __ovld __cnfn convert_char16(uint16);

char16 __ovld __cnfn convert_char16_sat(uint16);

char16 __ovld __cnfn convert_char16_rte(long16);

char16 __ovld __cnfn convert_char16_sat_rte(long16);

char16 __ovld __cnfn convert_char16_rtz(long16);

char16 __ovld __cnfn convert_char16_sat_rtz(long16);

char16 __ovld __cnfn convert_char16_rtp(long16);

char16 __ovld __cnfn convert_char16_sat_rtp(long16);

char16 __ovld __cnfn convert_char16_rtn(long16);

char16 __ovld __cnfn convert_char16_sat_rtn(long16);

char16 __ovld __cnfn convert_char16(long16);

char16 __ovld __cnfn convert_char16_sat(long16);

char16 __ovld __cnfn convert_char16_rte(ulong16);

char16 __ovld __cnfn convert_char16_sat_rte(ulong16);

char16 __ovld __cnfn convert_char16_rtz(ulong16);

char16 __ovld __cnfn convert_char16_sat_rtz(ulong16);

char16 __ovld __cnfn convert_char16_rtp(ulong16);

char16 __ovld __cnfn convert_char16_sat_rtp(ulong16);

char16 __ovld __cnfn convert_char16_rtn(ulong16);

char16 __ovld __cnfn convert_char16_sat_rtn(ulong16);

char16 __ovld __cnfn convert_char16(ulong16);

char16 __ovld __cnfn convert_char16_sat(ulong16);

char16 __ovld __cnfn convert_char16_rte(float16);

char16 __ovld __cnfn convert_char16_sat_rte(float16);

char16 __ovld __cnfn convert_char16_rtz(float16);

char16 __ovld __cnfn convert_char16_sat_rtz(float16);

char16 __ovld __cnfn convert_char16_rtp(float16);

char16 __ovld __cnfn convert_char16_sat_rtp(float16);

char16 __ovld __cnfn convert_char16_rtn(float16);

char16 __ovld __cnfn convert_char16_sat_rtn(float16);

char16 __ovld __cnfn convert_char16(float16);

char16 __ovld __cnfn convert_char16_sat(float16);

uchar16 __ovld __cnfn convert_uchar16_rte(char16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(char16);

uchar16 __ovld __cnfn convert_uchar16_rtz(char16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(char16);

uchar16 __ovld __cnfn convert_uchar16_rtp(char16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(char16);

uchar16 __ovld __cnfn convert_uchar16_rtn(char16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(char16);

uchar16 __ovld __cnfn convert_uchar16(char16);

uchar16 __ovld __cnfn convert_uchar16_sat(char16);

uchar16 __ovld __cnfn convert_uchar16_rte(uchar16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(uchar16);

uchar16 __ovld __cnfn convert_uchar16_rtz(uchar16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(uchar16);

uchar16 __ovld __cnfn convert_uchar16_rtp(uchar16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(uchar16);

uchar16 __ovld __cnfn convert_uchar16_rtn(uchar16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(uchar16);

uchar16 __ovld __cnfn convert_uchar16(uchar16);

uchar16 __ovld __cnfn convert_uchar16_sat(uchar16);

uchar16 __ovld __cnfn convert_uchar16_rte(short16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(short16);

uchar16 __ovld __cnfn convert_uchar16_rtz(short16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(short16);

uchar16 __ovld __cnfn convert_uchar16_rtp(short16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(short16);

uchar16 __ovld __cnfn convert_uchar16_rtn(short16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(short16);

uchar16 __ovld __cnfn convert_uchar16(short16);

uchar16 __ovld __cnfn convert_uchar16_sat(short16);

uchar16 __ovld __cnfn convert_uchar16_rte(ushort16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(ushort16);

uchar16 __ovld __cnfn convert_uchar16_rtz(ushort16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(ushort16);

uchar16 __ovld __cnfn convert_uchar16_rtp(ushort16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(ushort16);

uchar16 __ovld __cnfn convert_uchar16_rtn(ushort16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(ushort16);

uchar16 __ovld __cnfn convert_uchar16(ushort16);

uchar16 __ovld __cnfn convert_uchar16_sat(ushort16);

uchar16 __ovld __cnfn convert_uchar16_rte(int16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(int16);

uchar16 __ovld __cnfn convert_uchar16_rtz(int16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(int16);

uchar16 __ovld __cnfn convert_uchar16_rtp(int16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(int16);

uchar16 __ovld __cnfn convert_uchar16_rtn(int16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(int16);

uchar16 __ovld __cnfn convert_uchar16(int16);

uchar16 __ovld __cnfn convert_uchar16_sat(int16);

uchar16 __ovld __cnfn convert_uchar16_rte(uint16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(uint16);

uchar16 __ovld __cnfn convert_uchar16_rtz(uint16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(uint16);

uchar16 __ovld __cnfn convert_uchar16_rtp(uint16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(uint16);

uchar16 __ovld __cnfn convert_uchar16_rtn(uint16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(uint16);

uchar16 __ovld __cnfn convert_uchar16(uint16);

uchar16 __ovld __cnfn convert_uchar16_sat(uint16);

uchar16 __ovld __cnfn convert_uchar16_rte(long16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(long16);

uchar16 __ovld __cnfn convert_uchar16_rtz(long16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(long16);

uchar16 __ovld __cnfn convert_uchar16_rtp(long16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(long16);

uchar16 __ovld __cnfn convert_uchar16_rtn(long16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(long16);

uchar16 __ovld __cnfn convert_uchar16(long16);

uchar16 __ovld __cnfn convert_uchar16_sat(long16);

uchar16 __ovld __cnfn convert_uchar16_rte(ulong16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(ulong16);

uchar16 __ovld __cnfn convert_uchar16_rtz(ulong16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(ulong16);

uchar16 __ovld __cnfn convert_uchar16_rtp(ulong16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(ulong16);

uchar16 __ovld __cnfn convert_uchar16_rtn(ulong16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(ulong16);

uchar16 __ovld __cnfn convert_uchar16(ulong16);

uchar16 __ovld __cnfn convert_uchar16_sat(ulong16);

uchar16 __ovld __cnfn convert_uchar16_rte(float16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(float16);

uchar16 __ovld __cnfn convert_uchar16_rtz(float16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(float16);

uchar16 __ovld __cnfn convert_uchar16_rtp(float16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(float16);

uchar16 __ovld __cnfn convert_uchar16_rtn(float16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(float16);

uchar16 __ovld __cnfn convert_uchar16(float16);

uchar16 __ovld __cnfn convert_uchar16_sat(float16);

short16 __ovld __cnfn convert_short16_rte(char16);

short16 __ovld __cnfn convert_short16_sat_rte(char16);

short16 __ovld __cnfn convert_short16_rtz(char16);

short16 __ovld __cnfn convert_short16_sat_rtz(char16);

short16 __ovld __cnfn convert_short16_rtp(char16);

short16 __ovld __cnfn convert_short16_sat_rtp(char16);

short16 __ovld __cnfn convert_short16_rtn(char16);

short16 __ovld __cnfn convert_short16_sat_rtn(char16);

short16 __ovld __cnfn convert_short16(char16);

short16 __ovld __cnfn convert_short16_sat(char16);

short16 __ovld __cnfn convert_short16_rte(uchar16);

short16 __ovld __cnfn convert_short16_sat_rte(uchar16);

short16 __ovld __cnfn convert_short16_rtz(uchar16);

short16 __ovld __cnfn convert_short16_sat_rtz(uchar16);

short16 __ovld __cnfn convert_short16_rtp(uchar16);

short16 __ovld __cnfn convert_short16_sat_rtp(uchar16);

short16 __ovld __cnfn convert_short16_rtn(uchar16);

short16 __ovld __cnfn convert_short16_sat_rtn(uchar16);

short16 __ovld __cnfn convert_short16(uchar16);

short16 __ovld __cnfn convert_short16_sat(uchar16);

short16 __ovld __cnfn convert_short16_rte(short16);

short16 __ovld __cnfn convert_short16_sat_rte(short16);

short16 __ovld __cnfn convert_short16_rtz(short16);

short16 __ovld __cnfn convert_short16_sat_rtz(short16);

short16 __ovld __cnfn convert_short16_rtp(short16);

short16 __ovld __cnfn convert_short16_sat_rtp(short16);

short16 __ovld __cnfn convert_short16_rtn(short16);

short16 __ovld __cnfn convert_short16_sat_rtn(short16);

short16 __ovld __cnfn convert_short16(short16);

short16 __ovld __cnfn convert_short16_sat(short16);

short16 __ovld __cnfn convert_short16_rte(ushort16);

short16 __ovld __cnfn convert_short16_sat_rte(ushort16);

short16 __ovld __cnfn convert_short16_rtz(ushort16);

short16 __ovld __cnfn convert_short16_sat_rtz(ushort16);

short16 __ovld __cnfn convert_short16_rtp(ushort16);

short16 __ovld __cnfn convert_short16_sat_rtp(ushort16);

short16 __ovld __cnfn convert_short16_rtn(ushort16);

short16 __ovld __cnfn convert_short16_sat_rtn(ushort16);

short16 __ovld __cnfn convert_short16(ushort16);

short16 __ovld __cnfn convert_short16_sat(ushort16);

short16 __ovld __cnfn convert_short16_rte(int16);

short16 __ovld __cnfn convert_short16_sat_rte(int16);

short16 __ovld __cnfn convert_short16_rtz(int16);

short16 __ovld __cnfn convert_short16_sat_rtz(int16);

short16 __ovld __cnfn convert_short16_rtp(int16);

short16 __ovld __cnfn convert_short16_sat_rtp(int16);

short16 __ovld __cnfn convert_short16_rtn(int16);

short16 __ovld __cnfn convert_short16_sat_rtn(int16);

short16 __ovld __cnfn convert_short16(int16);

short16 __ovld __cnfn convert_short16_sat(int16);

short16 __ovld __cnfn convert_short16_rte(uint16);

short16 __ovld __cnfn convert_short16_sat_rte(uint16);

short16 __ovld __cnfn convert_short16_rtz(uint16);

short16 __ovld __cnfn convert_short16_sat_rtz(uint16);

short16 __ovld __cnfn convert_short16_rtp(uint16);

short16 __ovld __cnfn convert_short16_sat_rtp(uint16);

short16 __ovld __cnfn convert_short16_rtn(uint16);

short16 __ovld __cnfn convert_short16_sat_rtn(uint16);

short16 __ovld __cnfn convert_short16(uint16);

short16 __ovld __cnfn convert_short16_sat(uint16);

short16 __ovld __cnfn convert_short16_rte(long16);

short16 __ovld __cnfn convert_short16_sat_rte(long16);

short16 __ovld __cnfn convert_short16_rtz(long16);

short16 __ovld __cnfn convert_short16_sat_rtz(long16);

short16 __ovld __cnfn convert_short16_rtp(long16);

short16 __ovld __cnfn convert_short16_sat_rtp(long16);

short16 __ovld __cnfn convert_short16_rtn(long16);

short16 __ovld __cnfn convert_short16_sat_rtn(long16);

short16 __ovld __cnfn convert_short16(long16);

short16 __ovld __cnfn convert_short16_sat(long16);

short16 __ovld __cnfn convert_short16_rte(ulong16);

short16 __ovld __cnfn convert_short16_sat_rte(ulong16);

short16 __ovld __cnfn convert_short16_rtz(ulong16);

short16 __ovld __cnfn convert_short16_sat_rtz(ulong16);

short16 __ovld __cnfn convert_short16_rtp(ulong16);

short16 __ovld __cnfn convert_short16_sat_rtp(ulong16);

short16 __ovld __cnfn convert_short16_rtn(ulong16);

short16 __ovld __cnfn convert_short16_sat_rtn(ulong16);

short16 __ovld __cnfn convert_short16(ulong16);

short16 __ovld __cnfn convert_short16_sat(ulong16);

short16 __ovld __cnfn convert_short16_rte(float16);

short16 __ovld __cnfn convert_short16_sat_rte(float16);

short16 __ovld __cnfn convert_short16_rtz(float16);

short16 __ovld __cnfn convert_short16_sat_rtz(float16);

short16 __ovld __cnfn convert_short16_rtp(float16);

short16 __ovld __cnfn convert_short16_sat_rtp(float16);

short16 __ovld __cnfn convert_short16_rtn(float16);

short16 __ovld __cnfn convert_short16_sat_rtn(float16);

short16 __ovld __cnfn convert_short16(float16);

short16 __ovld __cnfn convert_short16_sat(float16);

ushort16 __ovld __cnfn convert_ushort16_rte(char16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(char16);

ushort16 __ovld __cnfn convert_ushort16_rtz(char16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(char16);

ushort16 __ovld __cnfn convert_ushort16_rtp(char16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(char16);

ushort16 __ovld __cnfn convert_ushort16_rtn(char16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(char16);

ushort16 __ovld __cnfn convert_ushort16(char16);

ushort16 __ovld __cnfn convert_ushort16_sat(char16);

ushort16 __ovld __cnfn convert_ushort16_rte(uchar16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(uchar16);

ushort16 __ovld __cnfn convert_ushort16_rtz(uchar16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(uchar16);

ushort16 __ovld __cnfn convert_ushort16_rtp(uchar16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(uchar16);

ushort16 __ovld __cnfn convert_ushort16_rtn(uchar16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(uchar16);

ushort16 __ovld __cnfn convert_ushort16(uchar16);

ushort16 __ovld __cnfn convert_ushort16_sat(uchar16);

ushort16 __ovld __cnfn convert_ushort16_rte(short16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(short16);

ushort16 __ovld __cnfn convert_ushort16_rtz(short16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(short16);

ushort16 __ovld __cnfn convert_ushort16_rtp(short16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(short16);

ushort16 __ovld __cnfn convert_ushort16_rtn(short16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(short16);

ushort16 __ovld __cnfn convert_ushort16(short16);

ushort16 __ovld __cnfn convert_ushort16_sat(short16);

ushort16 __ovld __cnfn convert_ushort16_rte(ushort16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(ushort16);

ushort16 __ovld __cnfn convert_ushort16_rtz(ushort16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(ushort16);

ushort16 __ovld __cnfn convert_ushort16_rtp(ushort16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(ushort16);

ushort16 __ovld __cnfn convert_ushort16_rtn(ushort16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(ushort16);

ushort16 __ovld __cnfn convert_ushort16(ushort16);

ushort16 __ovld __cnfn convert_ushort16_sat(ushort16);

ushort16 __ovld __cnfn convert_ushort16_rte(int16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(int16);

ushort16 __ovld __cnfn convert_ushort16_rtz(int16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(int16);

ushort16 __ovld __cnfn convert_ushort16_rtp(int16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(int16);

ushort16 __ovld __cnfn convert_ushort16_rtn(int16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(int16);

ushort16 __ovld __cnfn convert_ushort16(int16);

ushort16 __ovld __cnfn convert_ushort16_sat(int16);

ushort16 __ovld __cnfn convert_ushort16_rte(uint16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(uint16);

ushort16 __ovld __cnfn convert_ushort16_rtz(uint16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(uint16);

ushort16 __ovld __cnfn convert_ushort16_rtp(uint16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(uint16);

ushort16 __ovld __cnfn convert_ushort16_rtn(uint16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(uint16);

ushort16 __ovld __cnfn convert_ushort16(uint16);

ushort16 __ovld __cnfn convert_ushort16_sat(uint16);

ushort16 __ovld __cnfn convert_ushort16_rte(long16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(long16);

ushort16 __ovld __cnfn convert_ushort16_rtz(long16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(long16);

ushort16 __ovld __cnfn convert_ushort16_rtp(long16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(long16);

ushort16 __ovld __cnfn convert_ushort16_rtn(long16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(long16);

ushort16 __ovld __cnfn convert_ushort16(long16);

ushort16 __ovld __cnfn convert_ushort16_sat(long16);

ushort16 __ovld __cnfn convert_ushort16_rte(ulong16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(ulong16);

ushort16 __ovld __cnfn convert_ushort16_rtz(ulong16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(ulong16);

ushort16 __ovld __cnfn convert_ushort16_rtp(ulong16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(ulong16);

ushort16 __ovld __cnfn convert_ushort16_rtn(ulong16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(ulong16);

ushort16 __ovld __cnfn convert_ushort16(ulong16);

ushort16 __ovld __cnfn convert_ushort16_sat(ulong16);

ushort16 __ovld __cnfn convert_ushort16_rte(float16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(float16);

ushort16 __ovld __cnfn convert_ushort16_rtz(float16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(float16);

ushort16 __ovld __cnfn convert_ushort16_rtp(float16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(float16);

ushort16 __ovld __cnfn convert_ushort16_rtn(float16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(float16);

ushort16 __ovld __cnfn convert_ushort16(float16);

ushort16 __ovld __cnfn convert_ushort16_sat(float16);

int16 __ovld __cnfn convert_int16_rte(char16);

int16 __ovld __cnfn convert_int16_sat_rte(char16);

int16 __ovld __cnfn convert_int16_rtz(char16);

int16 __ovld __cnfn convert_int16_sat_rtz(char16);

int16 __ovld __cnfn convert_int16_rtp(char16);

int16 __ovld __cnfn convert_int16_sat_rtp(char16);

int16 __ovld __cnfn convert_int16_rtn(char16);

int16 __ovld __cnfn convert_int16_sat_rtn(char16);

int16 __ovld __cnfn convert_int16(char16);

int16 __ovld __cnfn convert_int16_sat(char16);

int16 __ovld __cnfn convert_int16_rte(uchar16);

int16 __ovld __cnfn convert_int16_sat_rte(uchar16);

int16 __ovld __cnfn convert_int16_rtz(uchar16);

int16 __ovld __cnfn convert_int16_sat_rtz(uchar16);

int16 __ovld __cnfn convert_int16_rtp(uchar16);

int16 __ovld __cnfn convert_int16_sat_rtp(uchar16);

int16 __ovld __cnfn convert_int16_rtn(uchar16);

int16 __ovld __cnfn convert_int16_sat_rtn(uchar16);

int16 __ovld __cnfn convert_int16(uchar16);

int16 __ovld __cnfn convert_int16_sat(uchar16);

int16 __ovld __cnfn convert_int16_rte(short16);

int16 __ovld __cnfn convert_int16_sat_rte(short16);

int16 __ovld __cnfn convert_int16_rtz(short16);

int16 __ovld __cnfn convert_int16_sat_rtz(short16);

int16 __ovld __cnfn convert_int16_rtp(short16);

int16 __ovld __cnfn convert_int16_sat_rtp(short16);

int16 __ovld __cnfn convert_int16_rtn(short16);

int16 __ovld __cnfn convert_int16_sat_rtn(short16);

int16 __ovld __cnfn convert_int16(short16);

int16 __ovld __cnfn convert_int16_sat(short16);

int16 __ovld __cnfn convert_int16_rte(ushort16);

int16 __ovld __cnfn convert_int16_sat_rte(ushort16);

int16 __ovld __cnfn convert_int16_rtz(ushort16);

int16 __ovld __cnfn convert_int16_sat_rtz(ushort16);

int16 __ovld __cnfn convert_int16_rtp(ushort16);

int16 __ovld __cnfn convert_int16_sat_rtp(ushort16);

int16 __ovld __cnfn convert_int16_rtn(ushort16);

int16 __ovld __cnfn convert_int16_sat_rtn(ushort16);

int16 __ovld __cnfn convert_int16(ushort16);

int16 __ovld __cnfn convert_int16_sat(ushort16);

int16 __ovld __cnfn convert_int16_rte(int16);

int16 __ovld __cnfn convert_int16_sat_rte(int16);

int16 __ovld __cnfn convert_int16_rtz(int16);

int16 __ovld __cnfn convert_int16_sat_rtz(int16);

int16 __ovld __cnfn convert_int16_rtp(int16);

int16 __ovld __cnfn convert_int16_sat_rtp(int16);

int16 __ovld __cnfn convert_int16_rtn(int16);

int16 __ovld __cnfn convert_int16_sat_rtn(int16);

int16 __ovld __cnfn convert_int16(int16);

int16 __ovld __cnfn convert_int16_sat(int16);

int16 __ovld __cnfn convert_int16_rte(uint16);

int16 __ovld __cnfn convert_int16_sat_rte(uint16);

int16 __ovld __cnfn convert_int16_rtz(uint16);

int16 __ovld __cnfn convert_int16_sat_rtz(uint16);

int16 __ovld __cnfn convert_int16_rtp(uint16);

int16 __ovld __cnfn convert_int16_sat_rtp(uint16);

int16 __ovld __cnfn convert_int16_rtn(uint16);

int16 __ovld __cnfn convert_int16_sat_rtn(uint16);

int16 __ovld __cnfn convert_int16(uint16);

int16 __ovld __cnfn convert_int16_sat(uint16);

int16 __ovld __cnfn convert_int16_rte(long16);

int16 __ovld __cnfn convert_int16_sat_rte(long16);

int16 __ovld __cnfn convert_int16_rtz(long16);

int16 __ovld __cnfn convert_int16_sat_rtz(long16);

int16 __ovld __cnfn convert_int16_rtp(long16);

int16 __ovld __cnfn convert_int16_sat_rtp(long16);

int16 __ovld __cnfn convert_int16_rtn(long16);

int16 __ovld __cnfn convert_int16_sat_rtn(long16);

int16 __ovld __cnfn convert_int16(long16);

int16 __ovld __cnfn convert_int16_sat(long16);

int16 __ovld __cnfn convert_int16_rte(ulong16);

int16 __ovld __cnfn convert_int16_sat_rte(ulong16);

int16 __ovld __cnfn convert_int16_rtz(ulong16);

int16 __ovld __cnfn convert_int16_sat_rtz(ulong16);

int16 __ovld __cnfn convert_int16_rtp(ulong16);

int16 __ovld __cnfn convert_int16_sat_rtp(ulong16);

int16 __ovld __cnfn convert_int16_rtn(ulong16);

int16 __ovld __cnfn convert_int16_sat_rtn(ulong16);

int16 __ovld __cnfn convert_int16(ulong16);

int16 __ovld __cnfn convert_int16_sat(ulong16);

int16 __ovld __cnfn convert_int16_rte(float16);

int16 __ovld __cnfn convert_int16_sat_rte(float16);

int16 __ovld __cnfn convert_int16_rtz(float16);

int16 __ovld __cnfn convert_int16_sat_rtz(float16);

int16 __ovld __cnfn convert_int16_rtp(float16);

int16 __ovld __cnfn convert_int16_sat_rtp(float16);

int16 __ovld __cnfn convert_int16_rtn(float16);

int16 __ovld __cnfn convert_int16_sat_rtn(float16);

int16 __ovld __cnfn convert_int16(float16);

int16 __ovld __cnfn convert_int16_sat(float16);

uint16 __ovld __cnfn convert_uint16_rte(char16);

uint16 __ovld __cnfn convert_uint16_sat_rte(char16);

uint16 __ovld __cnfn convert_uint16_rtz(char16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(char16);

uint16 __ovld __cnfn convert_uint16_rtp(char16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(char16);

uint16 __ovld __cnfn convert_uint16_rtn(char16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(char16);

uint16 __ovld __cnfn convert_uint16(char16);

uint16 __ovld __cnfn convert_uint16_sat(char16);

uint16 __ovld __cnfn convert_uint16_rte(uchar16);

uint16 __ovld __cnfn convert_uint16_sat_rte(uchar16);

uint16 __ovld __cnfn convert_uint16_rtz(uchar16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(uchar16);

uint16 __ovld __cnfn convert_uint16_rtp(uchar16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(uchar16);

uint16 __ovld __cnfn convert_uint16_rtn(uchar16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(uchar16);

uint16 __ovld __cnfn convert_uint16(uchar16);

uint16 __ovld __cnfn convert_uint16_sat(uchar16);

uint16 __ovld __cnfn convert_uint16_rte(short16);

uint16 __ovld __cnfn convert_uint16_sat_rte(short16);

uint16 __ovld __cnfn convert_uint16_rtz(short16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(short16);

uint16 __ovld __cnfn convert_uint16_rtp(short16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(short16);

uint16 __ovld __cnfn convert_uint16_rtn(short16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(short16);

uint16 __ovld __cnfn convert_uint16(short16);

uint16 __ovld __cnfn convert_uint16_sat(short16);

uint16 __ovld __cnfn convert_uint16_rte(ushort16);

uint16 __ovld __cnfn convert_uint16_sat_rte(ushort16);

uint16 __ovld __cnfn convert_uint16_rtz(ushort16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(ushort16);

uint16 __ovld __cnfn convert_uint16_rtp(ushort16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(ushort16);

uint16 __ovld __cnfn convert_uint16_rtn(ushort16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(ushort16);

uint16 __ovld __cnfn convert_uint16(ushort16);

uint16 __ovld __cnfn convert_uint16_sat(ushort16);

uint16 __ovld __cnfn convert_uint16_rte(int16);

uint16 __ovld __cnfn convert_uint16_sat_rte(int16);

uint16 __ovld __cnfn convert_uint16_rtz(int16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(int16);

uint16 __ovld __cnfn convert_uint16_rtp(int16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(int16);

uint16 __ovld __cnfn convert_uint16_rtn(int16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(int16);

uint16 __ovld __cnfn convert_uint16(int16);

uint16 __ovld __cnfn convert_uint16_sat(int16);

uint16 __ovld __cnfn convert_uint16_rte(uint16);

uint16 __ovld __cnfn convert_uint16_sat_rte(uint16);

uint16 __ovld __cnfn convert_uint16_rtz(uint16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(uint16);

uint16 __ovld __cnfn convert_uint16_rtp(uint16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(uint16);

uint16 __ovld __cnfn convert_uint16_rtn(uint16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(uint16);

uint16 __ovld __cnfn convert_uint16(uint16);

uint16 __ovld __cnfn convert_uint16_sat(uint16);

uint16 __ovld __cnfn convert_uint16_rte(long16);

uint16 __ovld __cnfn convert_uint16_sat_rte(long16);

uint16 __ovld __cnfn convert_uint16_rtz(long16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(long16);

uint16 __ovld __cnfn convert_uint16_rtp(long16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(long16);

uint16 __ovld __cnfn convert_uint16_rtn(long16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(long16);

uint16 __ovld __cnfn convert_uint16(long16);

uint16 __ovld __cnfn convert_uint16_sat(long16);

uint16 __ovld __cnfn convert_uint16_rte(ulong16);

uint16 __ovld __cnfn convert_uint16_sat_rte(ulong16);

uint16 __ovld __cnfn convert_uint16_rtz(ulong16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(ulong16);

uint16 __ovld __cnfn convert_uint16_rtp(ulong16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(ulong16);

uint16 __ovld __cnfn convert_uint16_rtn(ulong16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(ulong16);

uint16 __ovld __cnfn convert_uint16(ulong16);

uint16 __ovld __cnfn convert_uint16_sat(ulong16);

uint16 __ovld __cnfn convert_uint16_rte(float16);

uint16 __ovld __cnfn convert_uint16_sat_rte(float16);

uint16 __ovld __cnfn convert_uint16_rtz(float16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(float16);

uint16 __ovld __cnfn convert_uint16_rtp(float16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(float16);

uint16 __ovld __cnfn convert_uint16_rtn(float16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(float16);

uint16 __ovld __cnfn convert_uint16(float16);

uint16 __ovld __cnfn convert_uint16_sat(float16);

long16 __ovld __cnfn convert_long16_rte(char16);

long16 __ovld __cnfn convert_long16_sat_rte(char16);

long16 __ovld __cnfn convert_long16_rtz(char16);

long16 __ovld __cnfn convert_long16_sat_rtz(char16);

long16 __ovld __cnfn convert_long16_rtp(char16);

long16 __ovld __cnfn convert_long16_sat_rtp(char16);

long16 __ovld __cnfn convert_long16_rtn(char16);

long16 __ovld __cnfn convert_long16_sat_rtn(char16);

long16 __ovld __cnfn convert_long16(char16);

long16 __ovld __cnfn convert_long16_sat(char16);

long16 __ovld __cnfn convert_long16_rte(uchar16);

long16 __ovld __cnfn convert_long16_sat_rte(uchar16);

long16 __ovld __cnfn convert_long16_rtz(uchar16);

long16 __ovld __cnfn convert_long16_sat_rtz(uchar16);

long16 __ovld __cnfn convert_long16_rtp(uchar16);

long16 __ovld __cnfn convert_long16_sat_rtp(uchar16);

long16 __ovld __cnfn convert_long16_rtn(uchar16);

long16 __ovld __cnfn convert_long16_sat_rtn(uchar16);

long16 __ovld __cnfn convert_long16(uchar16);

long16 __ovld __cnfn convert_long16_sat(uchar16);

long16 __ovld __cnfn convert_long16_rte(short16);

long16 __ovld __cnfn convert_long16_sat_rte(short16);

long16 __ovld __cnfn convert_long16_rtz(short16);

long16 __ovld __cnfn convert_long16_sat_rtz(short16);

long16 __ovld __cnfn convert_long16_rtp(short16);

long16 __ovld __cnfn convert_long16_sat_rtp(short16);

long16 __ovld __cnfn convert_long16_rtn(short16);

long16 __ovld __cnfn convert_long16_sat_rtn(short16);

long16 __ovld __cnfn convert_long16(short16);

long16 __ovld __cnfn convert_long16_sat(short16);

long16 __ovld __cnfn convert_long16_rte(ushort16);

long16 __ovld __cnfn convert_long16_sat_rte(ushort16);

long16 __ovld __cnfn convert_long16_rtz(ushort16);

long16 __ovld __cnfn convert_long16_sat_rtz(ushort16);

long16 __ovld __cnfn convert_long16_rtp(ushort16);

long16 __ovld __cnfn convert_long16_sat_rtp(ushort16);

long16 __ovld __cnfn convert_long16_rtn(ushort16);

long16 __ovld __cnfn convert_long16_sat_rtn(ushort16);

long16 __ovld __cnfn convert_long16(ushort16);

long16 __ovld __cnfn convert_long16_sat(ushort16);

long16 __ovld __cnfn convert_long16_rte(int16);

long16 __ovld __cnfn convert_long16_sat_rte(int16);

long16 __ovld __cnfn convert_long16_rtz(int16);

long16 __ovld __cnfn convert_long16_sat_rtz(int16);

long16 __ovld __cnfn convert_long16_rtp(int16);

long16 __ovld __cnfn convert_long16_sat_rtp(int16);

long16 __ovld __cnfn convert_long16_rtn(int16);

long16 __ovld __cnfn convert_long16_sat_rtn(int16);

long16 __ovld __cnfn convert_long16(int16);

long16 __ovld __cnfn convert_long16_sat(int16);

long16 __ovld __cnfn convert_long16_rte(uint16);

long16 __ovld __cnfn convert_long16_sat_rte(uint16);

long16 __ovld __cnfn convert_long16_rtz(uint16);

long16 __ovld __cnfn convert_long16_sat_rtz(uint16);

long16 __ovld __cnfn convert_long16_rtp(uint16);

long16 __ovld __cnfn convert_long16_sat_rtp(uint16);

long16 __ovld __cnfn convert_long16_rtn(uint16);

long16 __ovld __cnfn convert_long16_sat_rtn(uint16);

long16 __ovld __cnfn convert_long16(uint16);

long16 __ovld __cnfn convert_long16_sat(uint16);

long16 __ovld __cnfn convert_long16_rte(long16);

long16 __ovld __cnfn convert_long16_sat_rte(long16);

long16 __ovld __cnfn convert_long16_rtz(long16);

long16 __ovld __cnfn convert_long16_sat_rtz(long16);

long16 __ovld __cnfn convert_long16_rtp(long16);

long16 __ovld __cnfn convert_long16_sat_rtp(long16);

long16 __ovld __cnfn convert_long16_rtn(long16);

long16 __ovld __cnfn convert_long16_sat_rtn(long16);

long16 __ovld __cnfn convert_long16(long16);

long16 __ovld __cnfn convert_long16_sat(long16);

long16 __ovld __cnfn convert_long16_rte(ulong16);

long16 __ovld __cnfn convert_long16_sat_rte(ulong16);

long16 __ovld __cnfn convert_long16_rtz(ulong16);

long16 __ovld __cnfn convert_long16_sat_rtz(ulong16);

long16 __ovld __cnfn convert_long16_rtp(ulong16);

long16 __ovld __cnfn convert_long16_sat_rtp(ulong16);

long16 __ovld __cnfn convert_long16_rtn(ulong16);

long16 __ovld __cnfn convert_long16_sat_rtn(ulong16);

long16 __ovld __cnfn convert_long16(ulong16);

long16 __ovld __cnfn convert_long16_sat(ulong16);

long16 __ovld __cnfn convert_long16_rte(float16);

long16 __ovld __cnfn convert_long16_sat_rte(float16);

long16 __ovld __cnfn convert_long16_rtz(float16);

long16 __ovld __cnfn convert_long16_sat_rtz(float16);

long16 __ovld __cnfn convert_long16_rtp(float16);

long16 __ovld __cnfn convert_long16_sat_rtp(float16);

long16 __ovld __cnfn convert_long16_rtn(float16);

long16 __ovld __cnfn convert_long16_sat_rtn(float16);

long16 __ovld __cnfn convert_long16(float16);

long16 __ovld __cnfn convert_long16_sat(float16);

ulong16 __ovld __cnfn convert_ulong16_rte(char16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(char16);

ulong16 __ovld __cnfn convert_ulong16_rtz(char16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(char16);

ulong16 __ovld __cnfn convert_ulong16_rtp(char16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(char16);

ulong16 __ovld __cnfn convert_ulong16_rtn(char16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(char16);

ulong16 __ovld __cnfn convert_ulong16(char16);

ulong16 __ovld __cnfn convert_ulong16_sat(char16);

ulong16 __ovld __cnfn convert_ulong16_rte(uchar16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(uchar16);

ulong16 __ovld __cnfn convert_ulong16_rtz(uchar16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(uchar16);

ulong16 __ovld __cnfn convert_ulong16_rtp(uchar16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(uchar16);

ulong16 __ovld __cnfn convert_ulong16_rtn(uchar16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(uchar16);

ulong16 __ovld __cnfn convert_ulong16(uchar16);

ulong16 __ovld __cnfn convert_ulong16_sat(uchar16);

ulong16 __ovld __cnfn convert_ulong16_rte(short16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(short16);

ulong16 __ovld __cnfn convert_ulong16_rtz(short16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(short16);

ulong16 __ovld __cnfn convert_ulong16_rtp(short16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(short16);

ulong16 __ovld __cnfn convert_ulong16_rtn(short16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(short16);

ulong16 __ovld __cnfn convert_ulong16(short16);

ulong16 __ovld __cnfn convert_ulong16_sat(short16);

ulong16 __ovld __cnfn convert_ulong16_rte(ushort16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(ushort16);

ulong16 __ovld __cnfn convert_ulong16_rtz(ushort16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(ushort16);

ulong16 __ovld __cnfn convert_ulong16_rtp(ushort16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(ushort16);

ulong16 __ovld __cnfn convert_ulong16_rtn(ushort16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(ushort16);

ulong16 __ovld __cnfn convert_ulong16(ushort16);

ulong16 __ovld __cnfn convert_ulong16_sat(ushort16);

ulong16 __ovld __cnfn convert_ulong16_rte(int16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(int16);

ulong16 __ovld __cnfn convert_ulong16_rtz(int16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(int16);

ulong16 __ovld __cnfn convert_ulong16_rtp(int16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(int16);

ulong16 __ovld __cnfn convert_ulong16_rtn(int16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(int16);

ulong16 __ovld __cnfn convert_ulong16(int16);

ulong16 __ovld __cnfn convert_ulong16_sat(int16);

ulong16 __ovld __cnfn convert_ulong16_rte(uint16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(uint16);

ulong16 __ovld __cnfn convert_ulong16_rtz(uint16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(uint16);

ulong16 __ovld __cnfn convert_ulong16_rtp(uint16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(uint16);

ulong16 __ovld __cnfn convert_ulong16_rtn(uint16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(uint16);

ulong16 __ovld __cnfn convert_ulong16(uint16);

ulong16 __ovld __cnfn convert_ulong16_sat(uint16);

ulong16 __ovld __cnfn convert_ulong16_rte(long16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(long16);

ulong16 __ovld __cnfn convert_ulong16_rtz(long16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(long16);

ulong16 __ovld __cnfn convert_ulong16_rtp(long16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(long16);

ulong16 __ovld __cnfn convert_ulong16_rtn(long16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(long16);

ulong16 __ovld __cnfn convert_ulong16(long16);

ulong16 __ovld __cnfn convert_ulong16_sat(long16);

ulong16 __ovld __cnfn convert_ulong16_rte(ulong16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(ulong16);

ulong16 __ovld __cnfn convert_ulong16_rtz(ulong16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(ulong16);

ulong16 __ovld __cnfn convert_ulong16_rtp(ulong16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(ulong16);

ulong16 __ovld __cnfn convert_ulong16_rtn(ulong16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(ulong16);

ulong16 __ovld __cnfn convert_ulong16(ulong16);

ulong16 __ovld __cnfn convert_ulong16_sat(ulong16);

ulong16 __ovld __cnfn convert_ulong16_rte(float16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(float16);

ulong16 __ovld __cnfn convert_ulong16_rtz(float16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(float16);

ulong16 __ovld __cnfn convert_ulong16_rtp(float16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(float16);

ulong16 __ovld __cnfn convert_ulong16_rtn(float16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(float16);

ulong16 __ovld __cnfn convert_ulong16(float16);

ulong16 __ovld __cnfn convert_ulong16_sat(float16);

float16 __ovld __cnfn convert_float16_rte(char16);

float16 __ovld __cnfn convert_float16_rtz(char16);

float16 __ovld __cnfn convert_float16_rtp(char16);

float16 __ovld __cnfn convert_float16_rtn(char16);

float16 __ovld __cnfn convert_float16(char16);

float16 __ovld __cnfn convert_float16_rte(uchar16);

float16 __ovld __cnfn convert_float16_rtz(uchar16);

float16 __ovld __cnfn convert_float16_rtp(uchar16);

float16 __ovld __cnfn convert_float16_rtn(uchar16);

float16 __ovld __cnfn convert_float16(uchar16);

float16 __ovld __cnfn convert_float16_rte(short16);

float16 __ovld __cnfn convert_float16_rtz(short16);

float16 __ovld __cnfn convert_float16_rtp(short16);

float16 __ovld __cnfn convert_float16_rtn(short16);

float16 __ovld __cnfn convert_float16(short16);

float16 __ovld __cnfn convert_float16_rte(ushort16);

float16 __ovld __cnfn convert_float16_rtz(ushort16);

float16 __ovld __cnfn convert_float16_rtp(ushort16);

float16 __ovld __cnfn convert_float16_rtn(ushort16);

float16 __ovld __cnfn convert_float16(ushort16);

float16 __ovld __cnfn convert_float16_rte(int16);

float16 __ovld __cnfn convert_float16_rtz(int16);

float16 __ovld __cnfn convert_float16_rtp(int16);

float16 __ovld __cnfn convert_float16_rtn(int16);

float16 __ovld __cnfn convert_float16(int16);

float16 __ovld __cnfn convert_float16_rte(uint16);

float16 __ovld __cnfn convert_float16_rtz(uint16);

float16 __ovld __cnfn convert_float16_rtp(uint16);

float16 __ovld __cnfn convert_float16_rtn(uint16);

float16 __ovld __cnfn convert_float16(uint16);

float16 __ovld __cnfn convert_float16_rte(long16);

float16 __ovld __cnfn convert_float16_rtz(long16);

float16 __ovld __cnfn convert_float16_rtp(long16);

float16 __ovld __cnfn convert_float16_rtn(long16);

float16 __ovld __cnfn convert_float16(long16);

float16 __ovld __cnfn convert_float16_rte(ulong16);

float16 __ovld __cnfn convert_float16_rtz(ulong16);

float16 __ovld __cnfn convert_float16_rtp(ulong16);

float16 __ovld __cnfn convert_float16_rtn(ulong16);

float16 __ovld __cnfn convert_float16(ulong16);

float16 __ovld __cnfn convert_float16_rte(float16);

float16 __ovld __cnfn convert_float16_rtz(float16);

float16 __ovld __cnfn convert_float16_rtp(float16);

float16 __ovld __cnfn convert_float16_rtn(float16);

float16 __ovld __cnfn convert_float16(float16);


// Conversions with double data type parameters or return value.


#ifdef cl_khr_fp64

char __ovld __cnfn convert_char(double);

char __ovld __cnfn convert_char_rte(double);

char __ovld __cnfn convert_char_rtn(double);

char __ovld __cnfn convert_char_rtp(double);

char __ovld __cnfn convert_char_rtz(double);

char __ovld __cnfn convert_char_sat(double);

char __ovld __cnfn convert_char_sat_rte(double);

char __ovld __cnfn convert_char_sat_rtn(double);

char __ovld __cnfn convert_char_sat_rtp(double);

char __ovld __cnfn convert_char_sat_rtz(double);

char2 __ovld __cnfn convert_char2(double2);

char2 __ovld __cnfn convert_char2_rte(double2);

char2 __ovld __cnfn convert_char2_rtn(double2);

char2 __ovld __cnfn convert_char2_rtp(double2);

char2 __ovld __cnfn convert_char2_rtz(double2);

char2 __ovld __cnfn convert_char2_sat(double2);

char2 __ovld __cnfn convert_char2_sat_rte(double2);

char2 __ovld __cnfn convert_char2_sat_rtn(double2);

char2 __ovld __cnfn convert_char2_sat_rtp(double2);

char2 __ovld __cnfn convert_char2_sat_rtz(double2);

char3 __ovld __cnfn convert_char3(double3);

char3 __ovld __cnfn convert_char3_rte(double3);

char3 __ovld __cnfn convert_char3_rtn(double3);

char3 __ovld __cnfn convert_char3_rtp(double3);

char3 __ovld __cnfn convert_char3_rtz(double3);

char3 __ovld __cnfn convert_char3_sat(double3);

char3 __ovld __cnfn convert_char3_sat_rte(double3);

char3 __ovld __cnfn convert_char3_sat_rtn(double3);

char3 __ovld __cnfn convert_char3_sat_rtp(double3);

char3 __ovld __cnfn convert_char3_sat_rtz(double3);

char4 __ovld __cnfn convert_char4(double4);

char4 __ovld __cnfn convert_char4_rte(double4);

char4 __ovld __cnfn convert_char4_rtn(double4);

char4 __ovld __cnfn convert_char4_rtp(double4);

char4 __ovld __cnfn convert_char4_rtz(double4);

char4 __ovld __cnfn convert_char4_sat(double4);

char4 __ovld __cnfn convert_char4_sat_rte(double4);

char4 __ovld __cnfn convert_char4_sat_rtn(double4);

char4 __ovld __cnfn convert_char4_sat_rtp(double4);

char4 __ovld __cnfn convert_char4_sat_rtz(double4);

char8 __ovld __cnfn convert_char8(double8);

char8 __ovld __cnfn convert_char8_rte(double8);

char8 __ovld __cnfn convert_char8_rtn(double8);

char8 __ovld __cnfn convert_char8_rtp(double8);

char8 __ovld __cnfn convert_char8_rtz(double8);

char8 __ovld __cnfn convert_char8_sat(double8);

char8 __ovld __cnfn convert_char8_sat_rte(double8);

char8 __ovld __cnfn convert_char8_sat_rtn(double8);

char8 __ovld __cnfn convert_char8_sat_rtp(double8);

char8 __ovld __cnfn convert_char8_sat_rtz(double8);

char16 __ovld __cnfn convert_char16(double16);

char16 __ovld __cnfn convert_char16_rte(double16);

char16 __ovld __cnfn convert_char16_rtn(double16);

char16 __ovld __cnfn convert_char16_rtp(double16);

char16 __ovld __cnfn convert_char16_rtz(double16);

char16 __ovld __cnfn convert_char16_sat(double16);

char16 __ovld __cnfn convert_char16_sat_rte(double16);

char16 __ovld __cnfn convert_char16_sat_rtn(double16);

char16 __ovld __cnfn convert_char16_sat_rtp(double16);

char16 __ovld __cnfn convert_char16_sat_rtz(double16);


uchar __ovld __cnfn convert_uchar(double);

uchar __ovld __cnfn convert_uchar_rte(double);

uchar __ovld __cnfn convert_uchar_rtn(double);

uchar __ovld __cnfn convert_uchar_rtp(double);

uchar __ovld __cnfn convert_uchar_rtz(double);

uchar __ovld __cnfn convert_uchar_sat(double);

uchar __ovld __cnfn convert_uchar_sat_rte(double);

uchar __ovld __cnfn convert_uchar_sat_rtn(double);

uchar __ovld __cnfn convert_uchar_sat_rtp(double);

uchar __ovld __cnfn convert_uchar_sat_rtz(double);

uchar2 __ovld __cnfn convert_uchar2(double2);

uchar2 __ovld __cnfn convert_uchar2_rte(double2);

uchar2 __ovld __cnfn convert_uchar2_rtn(double2);

uchar2 __ovld __cnfn convert_uchar2_rtp(double2);

uchar2 __ovld __cnfn convert_uchar2_rtz(double2);

uchar2 __ovld __cnfn convert_uchar2_sat(double2);

uchar2 __ovld __cnfn convert_uchar2_sat_rte(double2);

uchar2 __ovld __cnfn convert_uchar2_sat_rtn(double2);

uchar2 __ovld __cnfn convert_uchar2_sat_rtp(double2);

uchar2 __ovld __cnfn convert_uchar2_sat_rtz(double2);

uchar3 __ovld __cnfn convert_uchar3(double3);

uchar3 __ovld __cnfn convert_uchar3_rte(double3);

uchar3 __ovld __cnfn convert_uchar3_rtn(double3);

uchar3 __ovld __cnfn convert_uchar3_rtp(double3);

uchar3 __ovld __cnfn convert_uchar3_rtz(double3);

uchar3 __ovld __cnfn convert_uchar3_sat(double3);

uchar3 __ovld __cnfn convert_uchar3_sat_rte(double3);

uchar3 __ovld __cnfn convert_uchar3_sat_rtn(double3);

uchar3 __ovld __cnfn convert_uchar3_sat_rtp(double3);

uchar3 __ovld __cnfn convert_uchar3_sat_rtz(double3);

uchar4 __ovld __cnfn convert_uchar4(double4);

uchar4 __ovld __cnfn convert_uchar4_rte(double4);

uchar4 __ovld __cnfn convert_uchar4_rtn(double4);

uchar4 __ovld __cnfn convert_uchar4_rtp(double4);

uchar4 __ovld __cnfn convert_uchar4_rtz(double4);

uchar4 __ovld __cnfn convert_uchar4_sat(double4);

uchar4 __ovld __cnfn convert_uchar4_sat_rte(double4);

uchar4 __ovld __cnfn convert_uchar4_sat_rtn(double4);

uchar4 __ovld __cnfn convert_uchar4_sat_rtp(double4);

uchar4 __ovld __cnfn convert_uchar4_sat_rtz(double4);

uchar8 __ovld __cnfn convert_uchar8(double8);

uchar8 __ovld __cnfn convert_uchar8_rte(double8);

uchar8 __ovld __cnfn convert_uchar8_rtn(double8);

uchar8 __ovld __cnfn convert_uchar8_rtp(double8);

uchar8 __ovld __cnfn convert_uchar8_rtz(double8);

uchar8 __ovld __cnfn convert_uchar8_sat(double8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(double8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(double8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(double8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(double8);

uchar16 __ovld __cnfn convert_uchar16(double16);

uchar16 __ovld __cnfn convert_uchar16_rte(double16);

uchar16 __ovld __cnfn convert_uchar16_rtn(double16);

uchar16 __ovld __cnfn convert_uchar16_rtp(double16);

uchar16 __ovld __cnfn convert_uchar16_rtz(double16);

uchar16 __ovld __cnfn convert_uchar16_sat(double16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(double16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(double16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(double16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(double16);


short __ovld __cnfn convert_short(double);

short __ovld __cnfn convert_short_rte(double);

short __ovld __cnfn convert_short_rtn(double);

short __ovld __cnfn convert_short_rtp(double);

short __ovld __cnfn convert_short_rtz(double);

short __ovld __cnfn convert_short_sat(double);

short __ovld __cnfn convert_short_sat_rte(double);

short __ovld __cnfn convert_short_sat_rtn(double);

short __ovld __cnfn convert_short_sat_rtp(double);

short __ovld __cnfn convert_short_sat_rtz(double);

short2 __ovld __cnfn convert_short2(double2);

short2 __ovld __cnfn convert_short2_rte(double2);

short2 __ovld __cnfn convert_short2_rtn(double2);

short2 __ovld __cnfn convert_short2_rtp(double2);

short2 __ovld __cnfn convert_short2_rtz(double2);

short2 __ovld __cnfn convert_short2_sat(double2);

short2 __ovld __cnfn convert_short2_sat_rte(double2);

short2 __ovld __cnfn convert_short2_sat_rtn(double2);

short2 __ovld __cnfn convert_short2_sat_rtp(double2);

short2 __ovld __cnfn convert_short2_sat_rtz(double2);

short3 __ovld __cnfn convert_short3(double3);

short3 __ovld __cnfn convert_short3_rte(double3);

short3 __ovld __cnfn convert_short3_rtn(double3);

short3 __ovld __cnfn convert_short3_rtp(double3);

short3 __ovld __cnfn convert_short3_rtz(double3);

short3 __ovld __cnfn convert_short3_sat(double3);

short3 __ovld __cnfn convert_short3_sat_rte(double3);

short3 __ovld __cnfn convert_short3_sat_rtn(double3);

short3 __ovld __cnfn convert_short3_sat_rtp(double3);

short3 __ovld __cnfn convert_short3_sat_rtz(double3);

short4 __ovld __cnfn convert_short4(double4);

short4 __ovld __cnfn convert_short4_rte(double4);

short4 __ovld __cnfn convert_short4_rtn(double4);

short4 __ovld __cnfn convert_short4_rtp(double4);

short4 __ovld __cnfn convert_short4_rtz(double4);

short4 __ovld __cnfn convert_short4_sat(double4);

short4 __ovld __cnfn convert_short4_sat_rte(double4);

short4 __ovld __cnfn convert_short4_sat_rtn(double4);

short4 __ovld __cnfn convert_short4_sat_rtp(double4);

short4 __ovld __cnfn convert_short4_sat_rtz(double4);

short8 __ovld __cnfn convert_short8(double8);

short8 __ovld __cnfn convert_short8_rte(double8);

short8 __ovld __cnfn convert_short8_rtn(double8);

short8 __ovld __cnfn convert_short8_rtp(double8);

short8 __ovld __cnfn convert_short8_rtz(double8);

short8 __ovld __cnfn convert_short8_sat(double8);

short8 __ovld __cnfn convert_short8_sat_rte(double8);

short8 __ovld __cnfn convert_short8_sat_rtn(double8);

short8 __ovld __cnfn convert_short8_sat_rtp(double8);

short8 __ovld __cnfn convert_short8_sat_rtz(double8);

short16 __ovld __cnfn convert_short16(double16);

short16 __ovld __cnfn convert_short16_rte(double16);

short16 __ovld __cnfn convert_short16_rtn(double16);

short16 __ovld __cnfn convert_short16_rtp(double16);

short16 __ovld __cnfn convert_short16_rtz(double16);

short16 __ovld __cnfn convert_short16_sat(double16);

short16 __ovld __cnfn convert_short16_sat_rte(double16);

short16 __ovld __cnfn convert_short16_sat_rtn(double16);

short16 __ovld __cnfn convert_short16_sat_rtp(double16);

short16 __ovld __cnfn convert_short16_sat_rtz(double16);


ushort __ovld __cnfn convert_ushort(double);

ushort __ovld __cnfn convert_ushort_rte(double);

ushort __ovld __cnfn convert_ushort_rtn(double);

ushort __ovld __cnfn convert_ushort_rtp(double);

ushort __ovld __cnfn convert_ushort_rtz(double);

ushort __ovld __cnfn convert_ushort_sat(double);

ushort __ovld __cnfn convert_ushort_sat_rte(double);

ushort __ovld __cnfn convert_ushort_sat_rtn(double);

ushort __ovld __cnfn convert_ushort_sat_rtp(double);

ushort __ovld __cnfn convert_ushort_sat_rtz(double);

ushort2 __ovld __cnfn convert_ushort2(double2);

ushort2 __ovld __cnfn convert_ushort2_rte(double2);

ushort2 __ovld __cnfn convert_ushort2_rtn(double2);

ushort2 __ovld __cnfn convert_ushort2_rtp(double2);

ushort2 __ovld __cnfn convert_ushort2_rtz(double2);

ushort2 __ovld __cnfn convert_ushort2_sat(double2);

ushort2 __ovld __cnfn convert_ushort2_sat_rte(double2);

ushort2 __ovld __cnfn convert_ushort2_sat_rtn(double2);

ushort2 __ovld __cnfn convert_ushort2_sat_rtp(double2);

ushort2 __ovld __cnfn convert_ushort2_sat_rtz(double2);

ushort3 __ovld __cnfn convert_ushort3(double3);

ushort3 __ovld __cnfn convert_ushort3_rte(double3);

ushort3 __ovld __cnfn convert_ushort3_rtn(double3);

ushort3 __ovld __cnfn convert_ushort3_rtp(double3);

ushort3 __ovld __cnfn convert_ushort3_rtz(double3);

ushort3 __ovld __cnfn convert_ushort3_sat(double3);

ushort3 __ovld __cnfn convert_ushort3_sat_rte(double3);

ushort3 __ovld __cnfn convert_ushort3_sat_rtn(double3);

ushort3 __ovld __cnfn convert_ushort3_sat_rtp(double3);

ushort3 __ovld __cnfn convert_ushort3_sat_rtz(double3);

ushort4 __ovld __cnfn convert_ushort4(double4);

ushort4 __ovld __cnfn convert_ushort4_rte(double4);

ushort4 __ovld __cnfn convert_ushort4_rtn(double4);

ushort4 __ovld __cnfn convert_ushort4_rtp(double4);

ushort4 __ovld __cnfn convert_ushort4_rtz(double4);

ushort4 __ovld __cnfn convert_ushort4_sat(double4);

ushort4 __ovld __cnfn convert_ushort4_sat_rte(double4);

ushort4 __ovld __cnfn convert_ushort4_sat_rtn(double4);

ushort4 __ovld __cnfn convert_ushort4_sat_rtp(double4);

ushort4 __ovld __cnfn convert_ushort4_sat_rtz(double4);

ushort8 __ovld __cnfn convert_ushort8(double8);

ushort8 __ovld __cnfn convert_ushort8_rte(double8);

ushort8 __ovld __cnfn convert_ushort8_rtn(double8);

ushort8 __ovld __cnfn convert_ushort8_rtp(double8);

ushort8 __ovld __cnfn convert_ushort8_rtz(double8);

ushort8 __ovld __cnfn convert_ushort8_sat(double8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(double8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(double8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(double8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(double8);

ushort16 __ovld __cnfn convert_ushort16(double16);

ushort16 __ovld __cnfn convert_ushort16_rte(double16);

ushort16 __ovld __cnfn convert_ushort16_rtn(double16);

ushort16 __ovld __cnfn convert_ushort16_rtp(double16);

ushort16 __ovld __cnfn convert_ushort16_rtz(double16);

ushort16 __ovld __cnfn convert_ushort16_sat(double16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(double16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(double16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(double16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(double16);


int __ovld __cnfn convert_int(double);

int __ovld __cnfn convert_int_rte(double);

int __ovld __cnfn convert_int_rtn(double);

int __ovld __cnfn convert_int_rtp(double);

int __ovld __cnfn convert_int_rtz(double);

int __ovld __cnfn convert_int_sat(double);

int __ovld __cnfn convert_int_sat_rte(double);

int __ovld __cnfn convert_int_sat_rtn(double);

int __ovld __cnfn convert_int_sat_rtp(double);

int __ovld __cnfn convert_int_sat_rtz(double);

int2 __ovld __cnfn convert_int2(double2);

int2 __ovld __cnfn convert_int2_rte(double2);

int2 __ovld __cnfn convert_int2_rtn(double2);

int2 __ovld __cnfn convert_int2_rtp(double2);

int2 __ovld __cnfn convert_int2_rtz(double2);

int2 __ovld __cnfn convert_int2_sat(double2);

int2 __ovld __cnfn convert_int2_sat_rte(double2);

int2 __ovld __cnfn convert_int2_sat_rtn(double2);

int2 __ovld __cnfn convert_int2_sat_rtp(double2);

int2 __ovld __cnfn convert_int2_sat_rtz(double2);

int3 __ovld __cnfn convert_int3(double3);

int3 __ovld __cnfn convert_int3_rte(double3);

int3 __ovld __cnfn convert_int3_rtn(double3);

int3 __ovld __cnfn convert_int3_rtp(double3);

int3 __ovld __cnfn convert_int3_rtz(double3);

int3 __ovld __cnfn convert_int3_sat(double3);

int3 __ovld __cnfn convert_int3_sat_rte(double3);

int3 __ovld __cnfn convert_int3_sat_rtn(double3);

int3 __ovld __cnfn convert_int3_sat_rtp(double3);

int3 __ovld __cnfn convert_int3_sat_rtz(double3);

int4 __ovld __cnfn convert_int4(double4);

int4 __ovld __cnfn convert_int4_rte(double4);

int4 __ovld __cnfn convert_int4_rtn(double4);

int4 __ovld __cnfn convert_int4_rtp(double4);

int4 __ovld __cnfn convert_int4_rtz(double4);

int4 __ovld __cnfn convert_int4_sat(double4);

int4 __ovld __cnfn convert_int4_sat_rte(double4);

int4 __ovld __cnfn convert_int4_sat_rtn(double4);

int4 __ovld __cnfn convert_int4_sat_rtp(double4);

int4 __ovld __cnfn convert_int4_sat_rtz(double4);

int8 __ovld __cnfn convert_int8(double8);

int8 __ovld __cnfn convert_int8_rte(double8);

int8 __ovld __cnfn convert_int8_rtn(double8);

int8 __ovld __cnfn convert_int8_rtp(double8);

int8 __ovld __cnfn convert_int8_rtz(double8);

int8 __ovld __cnfn convert_int8_sat(double8);

int8 __ovld __cnfn convert_int8_sat_rte(double8);

int8 __ovld __cnfn convert_int8_sat_rtn(double8);

int8 __ovld __cnfn convert_int8_sat_rtp(double8);

int8 __ovld __cnfn convert_int8_sat_rtz(double8);

int16 __ovld __cnfn convert_int16(double16);

int16 __ovld __cnfn convert_int16_rte(double16);

int16 __ovld __cnfn convert_int16_rtn(double16);

int16 __ovld __cnfn convert_int16_rtp(double16);

int16 __ovld __cnfn convert_int16_rtz(double16);

int16 __ovld __cnfn convert_int16_sat(double16);

int16 __ovld __cnfn convert_int16_sat_rte(double16);

int16 __ovld __cnfn convert_int16_sat_rtn(double16);

int16 __ovld __cnfn convert_int16_sat_rtp(double16);

int16 __ovld __cnfn convert_int16_sat_rtz(double16);


uint __ovld __cnfn convert_uint(double);

uint __ovld __cnfn convert_uint_rte(double);

uint __ovld __cnfn convert_uint_rtn(double);

uint __ovld __cnfn convert_uint_rtp(double);

uint __ovld __cnfn convert_uint_rtz(double);

uint __ovld __cnfn convert_uint_sat(double);

uint __ovld __cnfn convert_uint_sat_rte(double);

uint __ovld __cnfn convert_uint_sat_rtn(double);

uint __ovld __cnfn convert_uint_sat_rtp(double);

uint __ovld __cnfn convert_uint_sat_rtz(double);

uint2 __ovld __cnfn convert_uint2(double2);

uint2 __ovld __cnfn convert_uint2_rte(double2);

uint2 __ovld __cnfn convert_uint2_rtn(double2);

uint2 __ovld __cnfn convert_uint2_rtp(double2);

uint2 __ovld __cnfn convert_uint2_rtz(double2);

uint2 __ovld __cnfn convert_uint2_sat(double2);

uint2 __ovld __cnfn convert_uint2_sat_rte(double2);

uint2 __ovld __cnfn convert_uint2_sat_rtn(double2);

uint2 __ovld __cnfn convert_uint2_sat_rtp(double2);

uint2 __ovld __cnfn convert_uint2_sat_rtz(double2);

uint3 __ovld __cnfn convert_uint3(double3);

uint3 __ovld __cnfn convert_uint3_rte(double3);

uint3 __ovld __cnfn convert_uint3_rtn(double3);

uint3 __ovld __cnfn convert_uint3_rtp(double3);

uint3 __ovld __cnfn convert_uint3_rtz(double3);

uint3 __ovld __cnfn convert_uint3_sat(double3);

uint3 __ovld __cnfn convert_uint3_sat_rte(double3);

uint3 __ovld __cnfn convert_uint3_sat_rtn(double3);

uint3 __ovld __cnfn convert_uint3_sat_rtp(double3);

uint3 __ovld __cnfn convert_uint3_sat_rtz(double3);

uint4 __ovld __cnfn convert_uint4(double4);

uint4 __ovld __cnfn convert_uint4_rte(double4);

uint4 __ovld __cnfn convert_uint4_rtn(double4);

uint4 __ovld __cnfn convert_uint4_rtp(double4);

uint4 __ovld __cnfn convert_uint4_rtz(double4);

uint4 __ovld __cnfn convert_uint4_sat(double4);

uint4 __ovld __cnfn convert_uint4_sat_rte(double4);

uint4 __ovld __cnfn convert_uint4_sat_rtn(double4);

uint4 __ovld __cnfn convert_uint4_sat_rtp(double4);

uint4 __ovld __cnfn convert_uint4_sat_rtz(double4);

uint8 __ovld __cnfn convert_uint8(double8);

uint8 __ovld __cnfn convert_uint8_rte(double8);

uint8 __ovld __cnfn convert_uint8_rtn(double8);

uint8 __ovld __cnfn convert_uint8_rtp(double8);

uint8 __ovld __cnfn convert_uint8_rtz(double8);

uint8 __ovld __cnfn convert_uint8_sat(double8);

uint8 __ovld __cnfn convert_uint8_sat_rte(double8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(double8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(double8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(double8);

uint16 __ovld __cnfn convert_uint16(double16);

uint16 __ovld __cnfn convert_uint16_rte(double16);

uint16 __ovld __cnfn convert_uint16_rtn(double16);

uint16 __ovld __cnfn convert_uint16_rtp(double16);

uint16 __ovld __cnfn convert_uint16_rtz(double16);

uint16 __ovld __cnfn convert_uint16_sat(double16);

uint16 __ovld __cnfn convert_uint16_sat_rte(double16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(double16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(double16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(double16);


long __ovld __cnfn convert_long(double);

long __ovld __cnfn convert_long_rte(double);

long __ovld __cnfn convert_long_rtn(double);

long __ovld __cnfn convert_long_rtp(double);

long __ovld __cnfn convert_long_rtz(double);

long __ovld __cnfn convert_long_sat(double);

long __ovld __cnfn convert_long_sat_rte(double);

long __ovld __cnfn convert_long_sat_rtn(double);

long __ovld __cnfn convert_long_sat_rtp(double);

long __ovld __cnfn convert_long_sat_rtz(double);

long2 __ovld __cnfn convert_long2(double2);

long2 __ovld __cnfn convert_long2_rte(double2);

long2 __ovld __cnfn convert_long2_rtn(double2);

long2 __ovld __cnfn convert_long2_rtp(double2);

long2 __ovld __cnfn convert_long2_rtz(double2);

long2 __ovld __cnfn convert_long2_sat(double2);

long2 __ovld __cnfn convert_long2_sat_rte(double2);

long2 __ovld __cnfn convert_long2_sat_rtn(double2);

long2 __ovld __cnfn convert_long2_sat_rtp(double2);

long2 __ovld __cnfn convert_long2_sat_rtz(double2);

long3 __ovld __cnfn convert_long3(double3);

long3 __ovld __cnfn convert_long3_rte(double3);

long3 __ovld __cnfn convert_long3_rtn(double3);

long3 __ovld __cnfn convert_long3_rtp(double3);

long3 __ovld __cnfn convert_long3_rtz(double3);

long3 __ovld __cnfn convert_long3_sat(double3);

long3 __ovld __cnfn convert_long3_sat_rte(double3);

long3 __ovld __cnfn convert_long3_sat_rtn(double3);

long3 __ovld __cnfn convert_long3_sat_rtp(double3);

long3 __ovld __cnfn convert_long3_sat_rtz(double3);

long4 __ovld __cnfn convert_long4(double4);

long4 __ovld __cnfn convert_long4_rte(double4);

long4 __ovld __cnfn convert_long4_rtn(double4);

long4 __ovld __cnfn convert_long4_rtp(double4);

long4 __ovld __cnfn convert_long4_rtz(double4);

long4 __ovld __cnfn convert_long4_sat(double4);

long4 __ovld __cnfn convert_long4_sat_rte(double4);

long4 __ovld __cnfn convert_long4_sat_rtn(double4);

long4 __ovld __cnfn convert_long4_sat_rtp(double4);

long4 __ovld __cnfn convert_long4_sat_rtz(double4);

long8 __ovld __cnfn convert_long8(double8);

long8 __ovld __cnfn convert_long8_rte(double8);

long8 __ovld __cnfn convert_long8_rtn(double8);

long8 __ovld __cnfn convert_long8_rtp(double8);

long8 __ovld __cnfn convert_long8_rtz(double8);

long8 __ovld __cnfn convert_long8_sat(double8);

long8 __ovld __cnfn convert_long8_sat_rte(double8);

long8 __ovld __cnfn convert_long8_sat_rtn(double8);

long8 __ovld __cnfn convert_long8_sat_rtp(double8);

long8 __ovld __cnfn convert_long8_sat_rtz(double8);

long16 __ovld __cnfn convert_long16(double16);

long16 __ovld __cnfn convert_long16_rte(double16);

long16 __ovld __cnfn convert_long16_rtn(double16);

long16 __ovld __cnfn convert_long16_rtp(double16);

long16 __ovld __cnfn convert_long16_rtz(double16);

long16 __ovld __cnfn convert_long16_sat(double16);

long16 __ovld __cnfn convert_long16_sat_rte(double16);

long16 __ovld __cnfn convert_long16_sat_rtn(double16);

long16 __ovld __cnfn convert_long16_sat_rtp(double16);

long16 __ovld __cnfn convert_long16_sat_rtz(double16);


ulong __ovld __cnfn convert_ulong(double);

ulong __ovld __cnfn convert_ulong_rte(double);

ulong __ovld __cnfn convert_ulong_rtn(double);

ulong __ovld __cnfn convert_ulong_rtp(double);

ulong __ovld __cnfn convert_ulong_rtz(double);

ulong __ovld __cnfn convert_ulong_sat(double);

ulong __ovld __cnfn convert_ulong_sat_rte(double);

ulong __ovld __cnfn convert_ulong_sat_rtn(double);

ulong __ovld __cnfn convert_ulong_sat_rtp(double);

ulong __ovld __cnfn convert_ulong_sat_rtz(double);

ulong2 __ovld __cnfn convert_ulong2(double2);

ulong2 __ovld __cnfn convert_ulong2_rte(double2);

ulong2 __ovld __cnfn convert_ulong2_rtn(double2);

ulong2 __ovld __cnfn convert_ulong2_rtp(double2);

ulong2 __ovld __cnfn convert_ulong2_rtz(double2);

ulong2 __ovld __cnfn convert_ulong2_sat(double2);

ulong2 __ovld __cnfn convert_ulong2_sat_rte(double2);

ulong2 __ovld __cnfn convert_ulong2_sat_rtn(double2);

ulong2 __ovld __cnfn convert_ulong2_sat_rtp(double2);

ulong2 __ovld __cnfn convert_ulong2_sat_rtz(double2);

ulong3 __ovld __cnfn convert_ulong3(double3);

ulong3 __ovld __cnfn convert_ulong3_rte(double3);

ulong3 __ovld __cnfn convert_ulong3_rtn(double3);

ulong3 __ovld __cnfn convert_ulong3_rtp(double3);

ulong3 __ovld __cnfn convert_ulong3_rtz(double3);

ulong3 __ovld __cnfn convert_ulong3_sat(double3);

ulong3 __ovld __cnfn convert_ulong3_sat_rte(double3);

ulong3 __ovld __cnfn convert_ulong3_sat_rtn(double3);

ulong3 __ovld __cnfn convert_ulong3_sat_rtp(double3);

ulong3 __ovld __cnfn convert_ulong3_sat_rtz(double3);

ulong4 __ovld __cnfn convert_ulong4(double4);

ulong4 __ovld __cnfn convert_ulong4_rte(double4);

ulong4 __ovld __cnfn convert_ulong4_rtn(double4);

ulong4 __ovld __cnfn convert_ulong4_rtp(double4);

ulong4 __ovld __cnfn convert_ulong4_rtz(double4);

ulong4 __ovld __cnfn convert_ulong4_sat(double4);

ulong4 __ovld __cnfn convert_ulong4_sat_rte(double4);

ulong4 __ovld __cnfn convert_ulong4_sat_rtn(double4);

ulong4 __ovld __cnfn convert_ulong4_sat_rtp(double4);

ulong4 __ovld __cnfn convert_ulong4_sat_rtz(double4);

ulong8 __ovld __cnfn convert_ulong8(double8);

ulong8 __ovld __cnfn convert_ulong8_rte(double8);

ulong8 __ovld __cnfn convert_ulong8_rtn(double8);

ulong8 __ovld __cnfn convert_ulong8_rtp(double8);

ulong8 __ovld __cnfn convert_ulong8_rtz(double8);

ulong8 __ovld __cnfn convert_ulong8_sat(double8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(double8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(double8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(double8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(double8);

ulong16 __ovld __cnfn convert_ulong16(double16);

ulong16 __ovld __cnfn convert_ulong16_rte(double16);

ulong16 __ovld __cnfn convert_ulong16_rtn(double16);

ulong16 __ovld __cnfn convert_ulong16_rtp(double16);

ulong16 __ovld __cnfn convert_ulong16_rtz(double16);

ulong16 __ovld __cnfn convert_ulong16_sat(double16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(double16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(double16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(double16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(double16);


float __ovld __cnfn convert_float(double);

float __ovld __cnfn convert_float_rte(double);

float __ovld __cnfn convert_float_rtn(double);

float __ovld __cnfn convert_float_rtp(double);

float __ovld __cnfn convert_float_rtz(double);

float2 __ovld __cnfn convert_float2(double2);

float2 __ovld __cnfn convert_float2_rte(double2);

float2 __ovld __cnfn convert_float2_rtn(double2);

float2 __ovld __cnfn convert_float2_rtp(double2);

float2 __ovld __cnfn convert_float2_rtz(double2);

float3 __ovld __cnfn convert_float3(double3);

float3 __ovld __cnfn convert_float3_rte(double3);

float3 __ovld __cnfn convert_float3_rtn(double3);

float3 __ovld __cnfn convert_float3_rtp(double3);

float3 __ovld __cnfn convert_float3_rtz(double3);

float4 __ovld __cnfn convert_float4(double4);

float4 __ovld __cnfn convert_float4_rte(double4);

float4 __ovld __cnfn convert_float4_rtn(double4);

float4 __ovld __cnfn convert_float4_rtp(double4);

float4 __ovld __cnfn convert_float4_rtz(double4);

float8 __ovld __cnfn convert_float8(double8);

float8 __ovld __cnfn convert_float8_rte(double8);

float8 __ovld __cnfn convert_float8_rtn(double8);

float8 __ovld __cnfn convert_float8_rtp(double8);

float8 __ovld __cnfn convert_float8_rtz(double8);

float16 __ovld __cnfn convert_float16(double16);

float16 __ovld __cnfn convert_float16_rte(double16);

float16 __ovld __cnfn convert_float16_rtn(double16);

float16 __ovld __cnfn convert_float16_rtp(double16);

float16 __ovld __cnfn convert_float16_rtz(double16);


double __ovld __cnfn convert_double(char);

double __ovld __cnfn convert_double(double);

double __ovld __cnfn convert_double(float);

double __ovld __cnfn convert_double(int);

double __ovld __cnfn convert_double(long);

double __ovld __cnfn convert_double(short);

double __ovld __cnfn convert_double(uchar);

double __ovld __cnfn convert_double(uint);

double __ovld __cnfn convert_double(ulong);

double __ovld __cnfn convert_double(ushort);

double __ovld __cnfn convert_double_rte(char);

double __ovld __cnfn convert_double_rte(double);

double __ovld __cnfn convert_double_rte(float);

double __ovld __cnfn convert_double_rte(int);

double __ovld __cnfn convert_double_rte(long);

double __ovld __cnfn convert_double_rte(short);

double __ovld __cnfn convert_double_rte(uchar);

double __ovld __cnfn convert_double_rte(uint);

double __ovld __cnfn convert_double_rte(ulong);

double __ovld __cnfn convert_double_rte(ushort);

double __ovld __cnfn convert_double_rtn(char);

double __ovld __cnfn convert_double_rtn(double);

double __ovld __cnfn convert_double_rtn(float);

double __ovld __cnfn convert_double_rtn(int);

double __ovld __cnfn convert_double_rtn(long);

double __ovld __cnfn convert_double_rtn(short);

double __ovld __cnfn convert_double_rtn(uchar);

double __ovld __cnfn convert_double_rtn(uint);

double __ovld __cnfn convert_double_rtn(ulong);

double __ovld __cnfn convert_double_rtn(ushort);

double __ovld __cnfn convert_double_rtp(char);

double __ovld __cnfn convert_double_rtp(double);

double __ovld __cnfn convert_double_rtp(float);

double __ovld __cnfn convert_double_rtp(int);

double __ovld __cnfn convert_double_rtp(long);

double __ovld __cnfn convert_double_rtp(short);

double __ovld __cnfn convert_double_rtp(uchar);

double __ovld __cnfn convert_double_rtp(uint);

double __ovld __cnfn convert_double_rtp(ulong);

double __ovld __cnfn convert_double_rtp(ushort);

double __ovld __cnfn convert_double_rtz(char);

double __ovld __cnfn convert_double_rtz(double);

double __ovld __cnfn convert_double_rtz(float);

double __ovld __cnfn convert_double_rtz(int);

double __ovld __cnfn convert_double_rtz(long);

double __ovld __cnfn convert_double_rtz(short);

double __ovld __cnfn convert_double_rtz(uchar);

double __ovld __cnfn convert_double_rtz(uint);

double __ovld __cnfn convert_double_rtz(ulong);

double __ovld __cnfn convert_double_rtz(ushort);

double2 __ovld __cnfn convert_double2(char2);

double2 __ovld __cnfn convert_double2(double2);

double2 __ovld __cnfn convert_double2(float2);

double2 __ovld __cnfn convert_double2(int2);

double2 __ovld __cnfn convert_double2(long2);

double2 __ovld __cnfn convert_double2(short2);

double2 __ovld __cnfn convert_double2(uchar2);

double2 __ovld __cnfn convert_double2(uint2);

double2 __ovld __cnfn convert_double2(ulong2);

double2 __ovld __cnfn convert_double2(ushort2);

double2 __ovld __cnfn convert_double2_rte(char2);

double2 __ovld __cnfn convert_double2_rte(double2);

double2 __ovld __cnfn convert_double2_rte(float2);

double2 __ovld __cnfn convert_double2_rte(int2);

double2 __ovld __cnfn convert_double2_rte(long2);

double2 __ovld __cnfn convert_double2_rte(short2);

double2 __ovld __cnfn convert_double2_rte(uchar2);

double2 __ovld __cnfn convert_double2_rte(uint2);

double2 __ovld __cnfn convert_double2_rte(ulong2);

double2 __ovld __cnfn convert_double2_rte(ushort2);

double2 __ovld __cnfn convert_double2_rtn(char2);

double2 __ovld __cnfn convert_double2_rtn(double2);

double2 __ovld __cnfn convert_double2_rtn(float2);

double2 __ovld __cnfn convert_double2_rtn(int2);

double2 __ovld __cnfn convert_double2_rtn(long2);

double2 __ovld __cnfn convert_double2_rtn(short2);

double2 __ovld __cnfn convert_double2_rtn(uchar2);

double2 __ovld __cnfn convert_double2_rtn(uint2);

double2 __ovld __cnfn convert_double2_rtn(ulong2);

double2 __ovld __cnfn convert_double2_rtn(ushort2);

double2 __ovld __cnfn convert_double2_rtp(char2);

double2 __ovld __cnfn convert_double2_rtp(double2);

double2 __ovld __cnfn convert_double2_rtp(float2);

double2 __ovld __cnfn convert_double2_rtp(int2);

double2 __ovld __cnfn convert_double2_rtp(long2);

double2 __ovld __cnfn convert_double2_rtp(short2);

double2 __ovld __cnfn convert_double2_rtp(uchar2);

double2 __ovld __cnfn convert_double2_rtp(uint2);

double2 __ovld __cnfn convert_double2_rtp(ulong2);

double2 __ovld __cnfn convert_double2_rtp(ushort2);

double2 __ovld __cnfn convert_double2_rtz(char2);

double2 __ovld __cnfn convert_double2_rtz(double2);

double2 __ovld __cnfn convert_double2_rtz(float2);

double2 __ovld __cnfn convert_double2_rtz(int2);

double2 __ovld __cnfn convert_double2_rtz(long2);

double2 __ovld __cnfn convert_double2_rtz(short2);

double2 __ovld __cnfn convert_double2_rtz(uchar2);

double2 __ovld __cnfn convert_double2_rtz(uint2);

double2 __ovld __cnfn convert_double2_rtz(ulong2);

double2 __ovld __cnfn convert_double2_rtz(ushort2);

double3 __ovld __cnfn convert_double3(char3);

double3 __ovld __cnfn convert_double3(double3);

double3 __ovld __cnfn convert_double3(float3);

double3 __ovld __cnfn convert_double3(int3);

double3 __ovld __cnfn convert_double3(long3);

double3 __ovld __cnfn convert_double3(short3);

double3 __ovld __cnfn convert_double3(uchar3);

double3 __ovld __cnfn convert_double3(uint3);

double3 __ovld __cnfn convert_double3(ulong3);

double3 __ovld __cnfn convert_double3(ushort3);

double3 __ovld __cnfn convert_double3_rte(char3);

double3 __ovld __cnfn convert_double3_rte(double3);

double3 __ovld __cnfn convert_double3_rte(float3);

double3 __ovld __cnfn convert_double3_rte(int3);

double3 __ovld __cnfn convert_double3_rte(long3);

double3 __ovld __cnfn convert_double3_rte(short3);

double3 __ovld __cnfn convert_double3_rte(uchar3);

double3 __ovld __cnfn convert_double3_rte(uint3);

double3 __ovld __cnfn convert_double3_rte(ulong3);

double3 __ovld __cnfn convert_double3_rte(ushort3);

double3 __ovld __cnfn convert_double3_rtn(char3);

double3 __ovld __cnfn convert_double3_rtn(double3);

double3 __ovld __cnfn convert_double3_rtn(float3);

double3 __ovld __cnfn convert_double3_rtn(int3);

double3 __ovld __cnfn convert_double3_rtn(long3);

double3 __ovld __cnfn convert_double3_rtn(short3);

double3 __ovld __cnfn convert_double3_rtn(uchar3);

double3 __ovld __cnfn convert_double3_rtn(uint3);

double3 __ovld __cnfn convert_double3_rtn(ulong3);

double3 __ovld __cnfn convert_double3_rtn(ushort3);

double3 __ovld __cnfn convert_double3_rtp(char3);

double3 __ovld __cnfn convert_double3_rtp(double3);

double3 __ovld __cnfn convert_double3_rtp(float3);

double3 __ovld __cnfn convert_double3_rtp(int3);

double3 __ovld __cnfn convert_double3_rtp(long3);

double3 __ovld __cnfn convert_double3_rtp(short3);

double3 __ovld __cnfn convert_double3_rtp(uchar3);

double3 __ovld __cnfn convert_double3_rtp(uint3);

double3 __ovld __cnfn convert_double3_rtp(ulong3);

double3 __ovld __cnfn convert_double3_rtp(ushort3);

double3 __ovld __cnfn convert_double3_rtz(char3);

double3 __ovld __cnfn convert_double3_rtz(double3);

double3 __ovld __cnfn convert_double3_rtz(float3);

double3 __ovld __cnfn convert_double3_rtz(int3);

double3 __ovld __cnfn convert_double3_rtz(long3);

double3 __ovld __cnfn convert_double3_rtz(short3);

double3 __ovld __cnfn convert_double3_rtz(uchar3);

double3 __ovld __cnfn convert_double3_rtz(uint3);

double3 __ovld __cnfn convert_double3_rtz(ulong3);

double3 __ovld __cnfn convert_double3_rtz(ushort3);

double4 __ovld __cnfn convert_double4(char4);

double4 __ovld __cnfn convert_double4(double4);

double4 __ovld __cnfn convert_double4(float4);

double4 __ovld __cnfn convert_double4(int4);

double4 __ovld __cnfn convert_double4(long4);

double4 __ovld __cnfn convert_double4(short4);

double4 __ovld __cnfn convert_double4(uchar4);

double4 __ovld __cnfn convert_double4(uint4);

double4 __ovld __cnfn convert_double4(ulong4);

double4 __ovld __cnfn convert_double4(ushort4);

double4 __ovld __cnfn convert_double4_rte(char4);

double4 __ovld __cnfn convert_double4_rte(double4);

double4 __ovld __cnfn convert_double4_rte(float4);

double4 __ovld __cnfn convert_double4_rte(int4);

double4 __ovld __cnfn convert_double4_rte(long4);

double4 __ovld __cnfn convert_double4_rte(short4);

double4 __ovld __cnfn convert_double4_rte(uchar4);

double4 __ovld __cnfn convert_double4_rte(uint4);

double4 __ovld __cnfn convert_double4_rte(ulong4);

double4 __ovld __cnfn convert_double4_rte(ushort4);

double4 __ovld __cnfn convert_double4_rtn(char4);

double4 __ovld __cnfn convert_double4_rtn(double4);

double4 __ovld __cnfn convert_double4_rtn(float4);

double4 __ovld __cnfn convert_double4_rtn(int4);

double4 __ovld __cnfn convert_double4_rtn(long4);

double4 __ovld __cnfn convert_double4_rtn(short4);

double4 __ovld __cnfn convert_double4_rtn(uchar4);

double4 __ovld __cnfn convert_double4_rtn(uint4);

double4 __ovld __cnfn convert_double4_rtn(ulong4);

double4 __ovld __cnfn convert_double4_rtn(ushort4);

double4 __ovld __cnfn convert_double4_rtp(char4);

double4 __ovld __cnfn convert_double4_rtp(double4);

double4 __ovld __cnfn convert_double4_rtp(float4);

double4 __ovld __cnfn convert_double4_rtp(int4);

double4 __ovld __cnfn convert_double4_rtp(long4);

double4 __ovld __cnfn convert_double4_rtp(short4);

double4 __ovld __cnfn convert_double4_rtp(uchar4);

double4 __ovld __cnfn convert_double4_rtp(uint4);

double4 __ovld __cnfn convert_double4_rtp(ulong4);

double4 __ovld __cnfn convert_double4_rtp(ushort4);

double4 __ovld __cnfn convert_double4_rtz(char4);

double4 __ovld __cnfn convert_double4_rtz(double4);

double4 __ovld __cnfn convert_double4_rtz(float4);

double4 __ovld __cnfn convert_double4_rtz(int4);

double4 __ovld __cnfn convert_double4_rtz(long4);

double4 __ovld __cnfn convert_double4_rtz(short4);

double4 __ovld __cnfn convert_double4_rtz(uchar4);

double4 __ovld __cnfn convert_double4_rtz(uint4);

double4 __ovld __cnfn convert_double4_rtz(ulong4);

double4 __ovld __cnfn convert_double4_rtz(ushort4);

double8 __ovld __cnfn convert_double8(char8);

double8 __ovld __cnfn convert_double8(double8);

double8 __ovld __cnfn convert_double8(float8);

double8 __ovld __cnfn convert_double8(int8);

double8 __ovld __cnfn convert_double8(long8);

double8 __ovld __cnfn convert_double8(short8);

double8 __ovld __cnfn convert_double8(uchar8);

double8 __ovld __cnfn convert_double8(uint8);

double8 __ovld __cnfn convert_double8(ulong8);

double8 __ovld __cnfn convert_double8(ushort8);

double8 __ovld __cnfn convert_double8_rte(char8);

double8 __ovld __cnfn convert_double8_rte(double8);

double8 __ovld __cnfn convert_double8_rte(float8);

double8 __ovld __cnfn convert_double8_rte(int8);

double8 __ovld __cnfn convert_double8_rte(long8);

double8 __ovld __cnfn convert_double8_rte(short8);

double8 __ovld __cnfn convert_double8_rte(uchar8);

double8 __ovld __cnfn convert_double8_rte(uint8);

double8 __ovld __cnfn convert_double8_rte(ulong8);

double8 __ovld __cnfn convert_double8_rte(ushort8);

double8 __ovld __cnfn convert_double8_rtn(char8);

double8 __ovld __cnfn convert_double8_rtn(double8);

double8 __ovld __cnfn convert_double8_rtn(float8);

double8 __ovld __cnfn convert_double8_rtn(int8);

double8 __ovld __cnfn convert_double8_rtn(long8);

double8 __ovld __cnfn convert_double8_rtn(short8);

double8 __ovld __cnfn convert_double8_rtn(uchar8);

double8 __ovld __cnfn convert_double8_rtn(uint8);

double8 __ovld __cnfn convert_double8_rtn(ulong8);

double8 __ovld __cnfn convert_double8_rtn(ushort8);

double8 __ovld __cnfn convert_double8_rtp(char8);

double8 __ovld __cnfn convert_double8_rtp(double8);

double8 __ovld __cnfn convert_double8_rtp(float8);

double8 __ovld __cnfn convert_double8_rtp(int8);

double8 __ovld __cnfn convert_double8_rtp(long8);

double8 __ovld __cnfn convert_double8_rtp(short8);

double8 __ovld __cnfn convert_double8_rtp(uchar8);

double8 __ovld __cnfn convert_double8_rtp(uint8);

double8 __ovld __cnfn convert_double8_rtp(ulong8);

double8 __ovld __cnfn convert_double8_rtp(ushort8);

double8 __ovld __cnfn convert_double8_rtz(char8);

double8 __ovld __cnfn convert_double8_rtz(double8);

double8 __ovld __cnfn convert_double8_rtz(float8);

double8 __ovld __cnfn convert_double8_rtz(int8);

double8 __ovld __cnfn convert_double8_rtz(long8);

double8 __ovld __cnfn convert_double8_rtz(short8);

double8 __ovld __cnfn convert_double8_rtz(uchar8);

double8 __ovld __cnfn convert_double8_rtz(uint8);

double8 __ovld __cnfn convert_double8_rtz(ulong8);

double8 __ovld __cnfn convert_double8_rtz(ushort8);

double16 __ovld __cnfn convert_double16(char16);

double16 __ovld __cnfn convert_double16(double16);

double16 __ovld __cnfn convert_double16(float16);

double16 __ovld __cnfn convert_double16(int16);

double16 __ovld __cnfn convert_double16(long16);

double16 __ovld __cnfn convert_double16(short16);

double16 __ovld __cnfn convert_double16(uchar16);

double16 __ovld __cnfn convert_double16(uint16);

double16 __ovld __cnfn convert_double16(ulong16);

double16 __ovld __cnfn convert_double16(ushort16);

double16 __ovld __cnfn convert_double16_rte(char16);

double16 __ovld __cnfn convert_double16_rte(double16);

double16 __ovld __cnfn convert_double16_rte(float16);

double16 __ovld __cnfn convert_double16_rte(int16);

double16 __ovld __cnfn convert_double16_rte(long16);

double16 __ovld __cnfn convert_double16_rte(short16);

double16 __ovld __cnfn convert_double16_rte(uchar16);

double16 __ovld __cnfn convert_double16_rte(uint16);

double16 __ovld __cnfn convert_double16_rte(ulong16);

double16 __ovld __cnfn convert_double16_rte(ushort16);

double16 __ovld __cnfn convert_double16_rtn(char16);

double16 __ovld __cnfn convert_double16_rtn(double16);

double16 __ovld __cnfn convert_double16_rtn(float16);

double16 __ovld __cnfn convert_double16_rtn(int16);

double16 __ovld __cnfn convert_double16_rtn(long16);

double16 __ovld __cnfn convert_double16_rtn(short16);

double16 __ovld __cnfn convert_double16_rtn(uchar16);

double16 __ovld __cnfn convert_double16_rtn(uint16);

double16 __ovld __cnfn convert_double16_rtn(ulong16);

double16 __ovld __cnfn convert_double16_rtn(ushort16);

double16 __ovld __cnfn convert_double16_rtp(char16);

double16 __ovld __cnfn convert_double16_rtp(double16);

double16 __ovld __cnfn convert_double16_rtp(float16);

double16 __ovld __cnfn convert_double16_rtp(int16);

double16 __ovld __cnfn convert_double16_rtp(long16);

double16 __ovld __cnfn convert_double16_rtp(short16);

double16 __ovld __cnfn convert_double16_rtp(uchar16);

double16 __ovld __cnfn convert_double16_rtp(uint16);

double16 __ovld __cnfn convert_double16_rtp(ulong16);

double16 __ovld __cnfn convert_double16_rtp(ushort16);

double16 __ovld __cnfn convert_double16_rtz(char16);

double16 __ovld __cnfn convert_double16_rtz(double16);

double16 __ovld __cnfn convert_double16_rtz(float16);

double16 __ovld __cnfn convert_double16_rtz(int16);

double16 __ovld __cnfn convert_double16_rtz(long16);

double16 __ovld __cnfn convert_double16_rtz(short16);

double16 __ovld __cnfn convert_double16_rtz(uchar16);

double16 __ovld __cnfn convert_double16_rtz(uint16);

double16 __ovld __cnfn convert_double16_rtz(ulong16);

double16 __ovld __cnfn convert_double16_rtz(ushort16);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

// Convert half types to non-double types.

uchar __ovld __cnfn convert_uchar(half);

uchar __ovld __cnfn convert_uchar_rte(half);

uchar __ovld __cnfn convert_uchar_rtp(half);

uchar __ovld __cnfn convert_uchar_rtn(half);

uchar __ovld __cnfn convert_uchar_rtz(half);

uchar __ovld __cnfn convert_uchar_sat(half);

uchar __ovld __cnfn convert_uchar_sat_rte(half);

uchar __ovld __cnfn convert_uchar_sat_rtp(half);

uchar __ovld __cnfn convert_uchar_sat_rtn(half);

uchar __ovld __cnfn convert_uchar_sat_rtz(half);

uchar2 __ovld __cnfn convert_uchar2(half2);

uchar2 __ovld __cnfn convert_uchar2_rte(half2);

uchar2 __ovld __cnfn convert_uchar2_rtp(half2);

uchar2 __ovld __cnfn convert_uchar2_rtn(half2);

uchar2 __ovld __cnfn convert_uchar2_rtz(half2);

uchar2 __ovld __cnfn convert_uchar2_sat(half2);

uchar2 __ovld __cnfn convert_uchar2_sat_rte(half2);

uchar2 __ovld __cnfn convert_uchar2_sat_rtp(half2);

uchar2 __ovld __cnfn convert_uchar2_sat_rtn(half2);

uchar2 __ovld __cnfn convert_uchar2_sat_rtz(half2);

uchar3 __ovld __cnfn convert_uchar3(half3);

uchar3 __ovld __cnfn convert_uchar3_rte(half3);

uchar3 __ovld __cnfn convert_uchar3_rtp(half3);

uchar3 __ovld __cnfn convert_uchar3_rtn(half3);

uchar3 __ovld __cnfn convert_uchar3_rtz(half3);

uchar3 __ovld __cnfn convert_uchar3_sat(half3);

uchar3 __ovld __cnfn convert_uchar3_sat_rte(half3);

uchar3 __ovld __cnfn convert_uchar3_sat_rtp(half3);

uchar3 __ovld __cnfn convert_uchar3_sat_rtn(half3);

uchar3 __ovld __cnfn convert_uchar3_sat_rtz(half3);

uchar4 __ovld __cnfn convert_uchar4(half4);

uchar4 __ovld __cnfn convert_uchar4_rte(half4);

uchar4 __ovld __cnfn convert_uchar4_rtp(half4);

uchar4 __ovld __cnfn convert_uchar4_rtn(half4);

uchar4 __ovld __cnfn convert_uchar4_rtz(half4);

uchar4 __ovld __cnfn convert_uchar4_sat(half4);

uchar4 __ovld __cnfn convert_uchar4_sat_rte(half4);

uchar4 __ovld __cnfn convert_uchar4_sat_rtp(half4);

uchar4 __ovld __cnfn convert_uchar4_sat_rtn(half4);

uchar4 __ovld __cnfn convert_uchar4_sat_rtz(half4);

uchar8 __ovld __cnfn convert_uchar8(half8);

uchar8 __ovld __cnfn convert_uchar8_rte(half8);

uchar8 __ovld __cnfn convert_uchar8_rtp(half8);

uchar8 __ovld __cnfn convert_uchar8_rtn(half8);

uchar8 __ovld __cnfn convert_uchar8_rtz(half8);

uchar8 __ovld __cnfn convert_uchar8_sat(half8);

uchar8 __ovld __cnfn convert_uchar8_sat_rte(half8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtp(half8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtn(half8);

uchar8 __ovld __cnfn convert_uchar8_sat_rtz(half8);

uchar16 __ovld __cnfn convert_uchar16(half16);

uchar16 __ovld __cnfn convert_uchar16_rte(half16);

uchar16 __ovld __cnfn convert_uchar16_rtp(half16);

uchar16 __ovld __cnfn convert_uchar16_rtn(half16);

uchar16 __ovld __cnfn convert_uchar16_rtz(half16);

uchar16 __ovld __cnfn convert_uchar16_sat(half16);

uchar16 __ovld __cnfn convert_uchar16_sat_rte(half16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtp(half16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtn(half16);

uchar16 __ovld __cnfn convert_uchar16_sat_rtz(half16);

ushort __ovld __cnfn convert_ushort(half);

ushort __ovld __cnfn convert_ushort_rte(half);

ushort __ovld __cnfn convert_ushort_rtp(half);

ushort __ovld __cnfn convert_ushort_rtn(half);

ushort __ovld __cnfn convert_ushort_rtz(half);

ushort __ovld __cnfn convert_ushort_sat(half);

ushort __ovld __cnfn convert_ushort_sat_rte(half);

ushort __ovld __cnfn convert_ushort_sat_rtp(half);

ushort __ovld __cnfn convert_ushort_sat_rtn(half);

ushort __ovld __cnfn convert_ushort_sat_rtz(half);

ushort2 __ovld __cnfn convert_ushort2(half2);

ushort2 __ovld __cnfn convert_ushort2_rte(half2);

ushort2 __ovld __cnfn convert_ushort2_rtp(half2);

ushort2 __ovld __cnfn convert_ushort2_rtn(half2);

ushort2 __ovld __cnfn convert_ushort2_rtz(half2);

ushort2 __ovld __cnfn convert_ushort2_sat(half2);

ushort2 __ovld __cnfn convert_ushort2_sat_rte(half2);

ushort2 __ovld __cnfn convert_ushort2_sat_rtp(half2);

ushort2 __ovld __cnfn convert_ushort2_sat_rtn(half2);

ushort2 __ovld __cnfn convert_ushort2_sat_rtz(half2);

ushort3 __ovld __cnfn convert_ushort3(half3);

ushort3 __ovld __cnfn convert_ushort3_rte(half3);

ushort3 __ovld __cnfn convert_ushort3_rtp(half3);

ushort3 __ovld __cnfn convert_ushort3_rtn(half3);

ushort3 __ovld __cnfn convert_ushort3_rtz(half3);

ushort3 __ovld __cnfn convert_ushort3_sat(half3);

ushort3 __ovld __cnfn convert_ushort3_sat_rte(half3);

ushort3 __ovld __cnfn convert_ushort3_sat_rtp(half3);

ushort3 __ovld __cnfn convert_ushort3_sat_rtn(half3);

ushort3 __ovld __cnfn convert_ushort3_sat_rtz(half3);

ushort4 __ovld __cnfn convert_ushort4(half4);

ushort4 __ovld __cnfn convert_ushort4_rte(half4);

ushort4 __ovld __cnfn convert_ushort4_rtp(half4);

ushort4 __ovld __cnfn convert_ushort4_rtn(half4);

ushort4 __ovld __cnfn convert_ushort4_rtz(half4);

ushort4 __ovld __cnfn convert_ushort4_sat(half4);

ushort4 __ovld __cnfn convert_ushort4_sat_rte(half4);

ushort4 __ovld __cnfn convert_ushort4_sat_rtp(half4);

ushort4 __ovld __cnfn convert_ushort4_sat_rtn(half4);

ushort4 __ovld __cnfn convert_ushort4_sat_rtz(half4);

ushort8 __ovld __cnfn convert_ushort8(half8);

ushort8 __ovld __cnfn convert_ushort8_rte(half8);

ushort8 __ovld __cnfn convert_ushort8_rtp(half8);

ushort8 __ovld __cnfn convert_ushort8_rtn(half8);

ushort8 __ovld __cnfn convert_ushort8_rtz(half8);

ushort8 __ovld __cnfn convert_ushort8_sat(half8);

ushort8 __ovld __cnfn convert_ushort8_sat_rte(half8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtp(half8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtn(half8);

ushort8 __ovld __cnfn convert_ushort8_sat_rtz(half8);

ushort16 __ovld __cnfn convert_ushort16(half16);

ushort16 __ovld __cnfn convert_ushort16_rte(half16);

ushort16 __ovld __cnfn convert_ushort16_rtp(half16);

ushort16 __ovld __cnfn convert_ushort16_rtn(half16);

ushort16 __ovld __cnfn convert_ushort16_rtz(half16);

ushort16 __ovld __cnfn convert_ushort16_sat(half16);

ushort16 __ovld __cnfn convert_ushort16_sat_rte(half16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtp(half16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtn(half16);

ushort16 __ovld __cnfn convert_ushort16_sat_rtz(half16);

uint __ovld __cnfn convert_uint(half);

uint __ovld __cnfn convert_uint_rte(half);

uint __ovld __cnfn convert_uint_rtp(half);

uint __ovld __cnfn convert_uint_rtn(half);

uint __ovld __cnfn convert_uint_rtz(half);

uint __ovld __cnfn convert_uint_sat(half);

uint __ovld __cnfn convert_uint_sat_rte(half);

uint __ovld __cnfn convert_uint_sat_rtp(half);

uint __ovld __cnfn convert_uint_sat_rtn(half);

uint __ovld __cnfn convert_uint_sat_rtz(half);

uint2 __ovld __cnfn convert_uint2(half2);

uint2 __ovld __cnfn convert_uint2_rte(half2);

uint2 __ovld __cnfn convert_uint2_rtp(half2);

uint2 __ovld __cnfn convert_uint2_rtn(half2);

uint2 __ovld __cnfn convert_uint2_rtz(half2);

uint2 __ovld __cnfn convert_uint2_sat(half2);

uint2 __ovld __cnfn convert_uint2_sat_rte(half2);

uint2 __ovld __cnfn convert_uint2_sat_rtp(half2);

uint2 __ovld __cnfn convert_uint2_sat_rtn(half2);

uint2 __ovld __cnfn convert_uint2_sat_rtz(half2);

uint3 __ovld __cnfn convert_uint3(half3);

uint3 __ovld __cnfn convert_uint3_rte(half3);

uint3 __ovld __cnfn convert_uint3_rtp(half3);

uint3 __ovld __cnfn convert_uint3_rtn(half3);

uint3 __ovld __cnfn convert_uint3_rtz(half3);

uint3 __ovld __cnfn convert_uint3_sat(half3);

uint3 __ovld __cnfn convert_uint3_sat_rte(half3);

uint3 __ovld __cnfn convert_uint3_sat_rtp(half3);

uint3 __ovld __cnfn convert_uint3_sat_rtn(half3);

uint3 __ovld __cnfn convert_uint3_sat_rtz(half3);

uint4 __ovld __cnfn convert_uint4(half4);

uint4 __ovld __cnfn convert_uint4_rte(half4);

uint4 __ovld __cnfn convert_uint4_rtp(half4);

uint4 __ovld __cnfn convert_uint4_rtn(half4);

uint4 __ovld __cnfn convert_uint4_rtz(half4);

uint4 __ovld __cnfn convert_uint4_sat(half4);

uint4 __ovld __cnfn convert_uint4_sat_rte(half4);

uint4 __ovld __cnfn convert_uint4_sat_rtp(half4);

uint4 __ovld __cnfn convert_uint4_sat_rtn(half4);

uint4 __ovld __cnfn convert_uint4_sat_rtz(half4);

uint8 __ovld __cnfn convert_uint8(half8);

uint8 __ovld __cnfn convert_uint8_rte(half8);

uint8 __ovld __cnfn convert_uint8_rtp(half8);

uint8 __ovld __cnfn convert_uint8_rtn(half8);

uint8 __ovld __cnfn convert_uint8_rtz(half8);

uint8 __ovld __cnfn convert_uint8_sat(half8);

uint8 __ovld __cnfn convert_uint8_sat_rte(half8);

uint8 __ovld __cnfn convert_uint8_sat_rtp(half8);

uint8 __ovld __cnfn convert_uint8_sat_rtn(half8);

uint8 __ovld __cnfn convert_uint8_sat_rtz(half8);

uint16 __ovld __cnfn convert_uint16(half16);

uint16 __ovld __cnfn convert_uint16_rte(half16);

uint16 __ovld __cnfn convert_uint16_rtp(half16);

uint16 __ovld __cnfn convert_uint16_rtn(half16);

uint16 __ovld __cnfn convert_uint16_rtz(half16);

uint16 __ovld __cnfn convert_uint16_sat(half16);

uint16 __ovld __cnfn convert_uint16_sat_rte(half16);

uint16 __ovld __cnfn convert_uint16_sat_rtp(half16);

uint16 __ovld __cnfn convert_uint16_sat_rtn(half16);

uint16 __ovld __cnfn convert_uint16_sat_rtz(half16);

ulong __ovld __cnfn convert_ulong(half);

ulong __ovld __cnfn convert_ulong_rte(half);

ulong __ovld __cnfn convert_ulong_rtp(half);

ulong __ovld __cnfn convert_ulong_rtn(half);

ulong __ovld __cnfn convert_ulong_rtz(half);

ulong __ovld __cnfn convert_ulong_sat(half);

ulong __ovld __cnfn convert_ulong_sat_rte(half);

ulong __ovld __cnfn convert_ulong_sat_rtp(half);

ulong __ovld __cnfn convert_ulong_sat_rtn(half);

ulong __ovld __cnfn convert_ulong_sat_rtz(half);

ulong2 __ovld __cnfn convert_ulong2(half2);

ulong2 __ovld __cnfn convert_ulong2_rte(half2);

ulong2 __ovld __cnfn convert_ulong2_rtp(half2);

ulong2 __ovld __cnfn convert_ulong2_rtn(half2);

ulong2 __ovld __cnfn convert_ulong2_rtz(half2);

ulong2 __ovld __cnfn convert_ulong2_sat(half2);

ulong2 __ovld __cnfn convert_ulong2_sat_rte(half2);

ulong2 __ovld __cnfn convert_ulong2_sat_rtp(half2);

ulong2 __ovld __cnfn convert_ulong2_sat_rtn(half2);

ulong2 __ovld __cnfn convert_ulong2_sat_rtz(half2);

ulong3 __ovld __cnfn convert_ulong3(half3);

ulong3 __ovld __cnfn convert_ulong3_rte(half3);

ulong3 __ovld __cnfn convert_ulong3_rtp(half3);

ulong3 __ovld __cnfn convert_ulong3_rtn(half3);

ulong3 __ovld __cnfn convert_ulong3_rtz(half3);

ulong3 __ovld __cnfn convert_ulong3_sat(half3);

ulong3 __ovld __cnfn convert_ulong3_sat_rte(half3);

ulong3 __ovld __cnfn convert_ulong3_sat_rtp(half3);

ulong3 __ovld __cnfn convert_ulong3_sat_rtn(half3);

ulong3 __ovld __cnfn convert_ulong3_sat_rtz(half3);

ulong4 __ovld __cnfn convert_ulong4(half4);

ulong4 __ovld __cnfn convert_ulong4_rte(half4);

ulong4 __ovld __cnfn convert_ulong4_rtp(half4);

ulong4 __ovld __cnfn convert_ulong4_rtn(half4);

ulong4 __ovld __cnfn convert_ulong4_rtz(half4);

ulong4 __ovld __cnfn convert_ulong4_sat(half4);

ulong4 __ovld __cnfn convert_ulong4_sat_rte(half4);

ulong4 __ovld __cnfn convert_ulong4_sat_rtp(half4);

ulong4 __ovld __cnfn convert_ulong4_sat_rtn(half4);

ulong4 __ovld __cnfn convert_ulong4_sat_rtz(half4);

ulong8 __ovld __cnfn convert_ulong8(half8);

ulong8 __ovld __cnfn convert_ulong8_rte(half8);

ulong8 __ovld __cnfn convert_ulong8_rtp(half8);

ulong8 __ovld __cnfn convert_ulong8_rtn(half8);

ulong8 __ovld __cnfn convert_ulong8_rtz(half8);

ulong8 __ovld __cnfn convert_ulong8_sat(half8);

ulong8 __ovld __cnfn convert_ulong8_sat_rte(half8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtp(half8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtn(half8);

ulong8 __ovld __cnfn convert_ulong8_sat_rtz(half8);

ulong16 __ovld __cnfn convert_ulong16(half16);

ulong16 __ovld __cnfn convert_ulong16_rte(half16);

ulong16 __ovld __cnfn convert_ulong16_rtp(half16);

ulong16 __ovld __cnfn convert_ulong16_rtn(half16);

ulong16 __ovld __cnfn convert_ulong16_rtz(half16);

ulong16 __ovld __cnfn convert_ulong16_sat(half16);

ulong16 __ovld __cnfn convert_ulong16_sat_rte(half16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtp(half16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtn(half16);

ulong16 __ovld __cnfn convert_ulong16_sat_rtz(half16);

char __ovld __cnfn convert_char(half);

char __ovld __cnfn convert_char_rte(half);

char __ovld __cnfn convert_char_rtp(half);

char __ovld __cnfn convert_char_rtn(half);

char __ovld __cnfn convert_char_rtz(half);

char __ovld __cnfn convert_char_sat(half);

char __ovld __cnfn convert_char_sat_rte(half);

char __ovld __cnfn convert_char_sat_rtp(half);

char __ovld __cnfn convert_char_sat_rtn(half);

char __ovld __cnfn convert_char_sat_rtz(half);

char2 __ovld __cnfn convert_char2(half2);

char2 __ovld __cnfn convert_char2_rte(half2);

char2 __ovld __cnfn convert_char2_rtp(half2);

char2 __ovld __cnfn convert_char2_rtn(half2);

char2 __ovld __cnfn convert_char2_rtz(half2);

char2 __ovld __cnfn convert_char2_sat(half2);

char2 __ovld __cnfn convert_char2_sat_rte(half2);

char2 __ovld __cnfn convert_char2_sat_rtp(half2);

char2 __ovld __cnfn convert_char2_sat_rtn(half2);

char2 __ovld __cnfn convert_char2_sat_rtz(half2);

char3 __ovld __cnfn convert_char3(half3);

char3 __ovld __cnfn convert_char3_rte(half3);

char3 __ovld __cnfn convert_char3_rtp(half3);

char3 __ovld __cnfn convert_char3_rtn(half3);

char3 __ovld __cnfn convert_char3_rtz(half3);

char3 __ovld __cnfn convert_char3_sat(half3);

char3 __ovld __cnfn convert_char3_sat_rte(half3);

char3 __ovld __cnfn convert_char3_sat_rtp(half3);

char3 __ovld __cnfn convert_char3_sat_rtn(half3);

char3 __ovld __cnfn convert_char3_sat_rtz(half3);

char4 __ovld __cnfn convert_char4(half4);

char4 __ovld __cnfn convert_char4_rte(half4);

char4 __ovld __cnfn convert_char4_rtp(half4);

char4 __ovld __cnfn convert_char4_rtn(half4);

char4 __ovld __cnfn convert_char4_rtz(half4);

char4 __ovld __cnfn convert_char4_sat(half4);

char4 __ovld __cnfn convert_char4_sat_rte(half4);

char4 __ovld __cnfn convert_char4_sat_rtp(half4);

char4 __ovld __cnfn convert_char4_sat_rtn(half4);

char4 __ovld __cnfn convert_char4_sat_rtz(half4);

char8 __ovld __cnfn convert_char8(half8);

char8 __ovld __cnfn convert_char8_rte(half8);

char8 __ovld __cnfn convert_char8_rtp(half8);

char8 __ovld __cnfn convert_char8_rtn(half8);

char8 __ovld __cnfn convert_char8_rtz(half8);

char8 __ovld __cnfn convert_char8_sat(half8);

char8 __ovld __cnfn convert_char8_sat_rte(half8);

char8 __ovld __cnfn convert_char8_sat_rtp(half8);

char8 __ovld __cnfn convert_char8_sat_rtn(half8);

char8 __ovld __cnfn convert_char8_sat_rtz(half8);

char16 __ovld __cnfn convert_char16(half16);

char16 __ovld __cnfn convert_char16_rte(half16);

char16 __ovld __cnfn convert_char16_rtp(half16);

char16 __ovld __cnfn convert_char16_rtn(half16);

char16 __ovld __cnfn convert_char16_rtz(half16);

char16 __ovld __cnfn convert_char16_sat(half16);

char16 __ovld __cnfn convert_char16_sat_rte(half16);

char16 __ovld __cnfn convert_char16_sat_rtp(half16);

char16 __ovld __cnfn convert_char16_sat_rtn(half16);

char16 __ovld __cnfn convert_char16_sat_rtz(half16);

short __ovld __cnfn convert_short(half);

short __ovld __cnfn convert_short_rte(half);

short __ovld __cnfn convert_short_rtp(half);

short __ovld __cnfn convert_short_rtn(half);

short __ovld __cnfn convert_short_rtz(half);

short __ovld __cnfn convert_short_sat(half);

short __ovld __cnfn convert_short_sat_rte(half);

short __ovld __cnfn convert_short_sat_rtp(half);

short __ovld __cnfn convert_short_sat_rtn(half);

short __ovld __cnfn convert_short_sat_rtz(half);

short2 __ovld __cnfn convert_short2(half2);

short2 __ovld __cnfn convert_short2_rte(half2);

short2 __ovld __cnfn convert_short2_rtp(half2);

short2 __ovld __cnfn convert_short2_rtn(half2);

short2 __ovld __cnfn convert_short2_rtz(half2);

short2 __ovld __cnfn convert_short2_sat(half2);

short2 __ovld __cnfn convert_short2_sat_rte(half2);

short2 __ovld __cnfn convert_short2_sat_rtp(half2);

short2 __ovld __cnfn convert_short2_sat_rtn(half2);

short2 __ovld __cnfn convert_short2_sat_rtz(half2);

short3 __ovld __cnfn convert_short3(half3);

short3 __ovld __cnfn convert_short3_rte(half3);

short3 __ovld __cnfn convert_short3_rtp(half3);

short3 __ovld __cnfn convert_short3_rtn(half3);

short3 __ovld __cnfn convert_short3_rtz(half3);

short3 __ovld __cnfn convert_short3_sat(half3);

short3 __ovld __cnfn convert_short3_sat_rte(half3);

short3 __ovld __cnfn convert_short3_sat_rtp(half3);

short3 __ovld __cnfn convert_short3_sat_rtn(half3);

short3 __ovld __cnfn convert_short3_sat_rtz(half3);

short4 __ovld __cnfn convert_short4(half4);

short4 __ovld __cnfn convert_short4_rte(half4);

short4 __ovld __cnfn convert_short4_rtp(half4);

short4 __ovld __cnfn convert_short4_rtn(half4);

short4 __ovld __cnfn convert_short4_rtz(half4);

short4 __ovld __cnfn convert_short4_sat(half4);

short4 __ovld __cnfn convert_short4_sat_rte(half4);

short4 __ovld __cnfn convert_short4_sat_rtp(half4);

short4 __ovld __cnfn convert_short4_sat_rtn(half4);

short4 __ovld __cnfn convert_short4_sat_rtz(half4);

short8 __ovld __cnfn convert_short8(half8);

short8 __ovld __cnfn convert_short8_rte(half8);

short8 __ovld __cnfn convert_short8_rtp(half8);

short8 __ovld __cnfn convert_short8_rtn(half8);

short8 __ovld __cnfn convert_short8_rtz(half8);

short8 __ovld __cnfn convert_short8_sat(half8);

short8 __ovld __cnfn convert_short8_sat_rte(half8);

short8 __ovld __cnfn convert_short8_sat_rtp(half8);

short8 __ovld __cnfn convert_short8_sat_rtn(half8);

short8 __ovld __cnfn convert_short8_sat_rtz(half8);

short16 __ovld __cnfn convert_short16(half16);

short16 __ovld __cnfn convert_short16_rte(half16);

short16 __ovld __cnfn convert_short16_rtp(half16);

short16 __ovld __cnfn convert_short16_rtn(half16);

short16 __ovld __cnfn convert_short16_rtz(half16);

short16 __ovld __cnfn convert_short16_sat(half16);

short16 __ovld __cnfn convert_short16_sat_rte(half16);

short16 __ovld __cnfn convert_short16_sat_rtp(half16);

short16 __ovld __cnfn convert_short16_sat_rtn(half16);

short16 __ovld __cnfn convert_short16_sat_rtz(half16);

int __ovld __cnfn convert_int(half);

int __ovld __cnfn convert_int_rte(half);

int __ovld __cnfn convert_int_rtp(half);

int __ovld __cnfn convert_int_rtn(half);

int __ovld __cnfn convert_int_rtz(half);

int __ovld __cnfn convert_int_sat(half);

int __ovld __cnfn convert_int_sat_rte(half);

int __ovld __cnfn convert_int_sat_rtp(half);

int __ovld __cnfn convert_int_sat_rtn(half);

int __ovld __cnfn convert_int_sat_rtz(half);

int2 __ovld __cnfn convert_int2(half2);

int2 __ovld __cnfn convert_int2_rte(half2);

int2 __ovld __cnfn convert_int2_rtp(half2);

int2 __ovld __cnfn convert_int2_rtn(half2);

int2 __ovld __cnfn convert_int2_rtz(half2);

int2 __ovld __cnfn convert_int2_sat(half2);

int2 __ovld __cnfn convert_int2_sat_rte(half2);

int2 __ovld __cnfn convert_int2_sat_rtp(half2);

int2 __ovld __cnfn convert_int2_sat_rtn(half2);

int2 __ovld __cnfn convert_int2_sat_rtz(half2);

int3 __ovld __cnfn convert_int3(half3);

int3 __ovld __cnfn convert_int3_rte(half3);

int3 __ovld __cnfn convert_int3_rtp(half3);

int3 __ovld __cnfn convert_int3_rtn(half3);

int3 __ovld __cnfn convert_int3_rtz(half3);

int3 __ovld __cnfn convert_int3_sat(half3);

int3 __ovld __cnfn convert_int3_sat_rte(half3);

int3 __ovld __cnfn convert_int3_sat_rtp(half3);

int3 __ovld __cnfn convert_int3_sat_rtn(half3);

int3 __ovld __cnfn convert_int3_sat_rtz(half3);

int4 __ovld __cnfn convert_int4(half4);

int4 __ovld __cnfn convert_int4_rte(half4);

int4 __ovld __cnfn convert_int4_rtp(half4);

int4 __ovld __cnfn convert_int4_rtn(half4);

int4 __ovld __cnfn convert_int4_rtz(half4);

int4 __ovld __cnfn convert_int4_sat(half4);

int4 __ovld __cnfn convert_int4_sat_rte(half4);

int4 __ovld __cnfn convert_int4_sat_rtp(half4);

int4 __ovld __cnfn convert_int4_sat_rtn(half4);

int4 __ovld __cnfn convert_int4_sat_rtz(half4);

int8 __ovld __cnfn convert_int8(half8);

int8 __ovld __cnfn convert_int8_rte(half8);

int8 __ovld __cnfn convert_int8_rtp(half8);

int8 __ovld __cnfn convert_int8_rtn(half8);

int8 __ovld __cnfn convert_int8_rtz(half8);

int8 __ovld __cnfn convert_int8_sat(half8);

int8 __ovld __cnfn convert_int8_sat_rte(half8);

int8 __ovld __cnfn convert_int8_sat_rtp(half8);

int8 __ovld __cnfn convert_int8_sat_rtn(half8);

int8 __ovld __cnfn convert_int8_sat_rtz(half8);

int16 __ovld __cnfn convert_int16(half16);

int16 __ovld __cnfn convert_int16_rte(half16);

int16 __ovld __cnfn convert_int16_rtp(half16);

int16 __ovld __cnfn convert_int16_rtn(half16);

int16 __ovld __cnfn convert_int16_rtz(half16);

int16 __ovld __cnfn convert_int16_sat(half16);

int16 __ovld __cnfn convert_int16_sat_rte(half16);

int16 __ovld __cnfn convert_int16_sat_rtp(half16);

int16 __ovld __cnfn convert_int16_sat_rtn(half16);

int16 __ovld __cnfn convert_int16_sat_rtz(half16);

long __ovld __cnfn convert_long(half);

long __ovld __cnfn convert_long_rte(half);

long __ovld __cnfn convert_long_rtp(half);

long __ovld __cnfn convert_long_rtn(half);

long __ovld __cnfn convert_long_rtz(half);

long __ovld __cnfn convert_long_sat(half);

long __ovld __cnfn convert_long_sat_rte(half);

long __ovld __cnfn convert_long_sat_rtp(half);

long __ovld __cnfn convert_long_sat_rtn(half);

long __ovld __cnfn convert_long_sat_rtz(half);

long2 __ovld __cnfn convert_long2(half2);

long2 __ovld __cnfn convert_long2_rte(half2);

long2 __ovld __cnfn convert_long2_rtp(half2);

long2 __ovld __cnfn convert_long2_rtn(half2);

long2 __ovld __cnfn convert_long2_rtz(half2);

long2 __ovld __cnfn convert_long2_sat(half2);

long2 __ovld __cnfn convert_long2_sat_rte(half2);

long2 __ovld __cnfn convert_long2_sat_rtp(half2);

long2 __ovld __cnfn convert_long2_sat_rtn(half2);

long2 __ovld __cnfn convert_long2_sat_rtz(half2);

long3 __ovld __cnfn convert_long3(half3);

long3 __ovld __cnfn convert_long3_rte(half3);

long3 __ovld __cnfn convert_long3_rtp(half3);

long3 __ovld __cnfn convert_long3_rtn(half3);

long3 __ovld __cnfn convert_long3_rtz(half3);

long3 __ovld __cnfn convert_long3_sat(half3);

long3 __ovld __cnfn convert_long3_sat_rte(half3);

long3 __ovld __cnfn convert_long3_sat_rtp(half3);

long3 __ovld __cnfn convert_long3_sat_rtn(half3);

long3 __ovld __cnfn convert_long3_sat_rtz(half3);

long4 __ovld __cnfn convert_long4(half4);

long4 __ovld __cnfn convert_long4_rte(half4);

long4 __ovld __cnfn convert_long4_rtp(half4);

long4 __ovld __cnfn convert_long4_rtn(half4);

long4 __ovld __cnfn convert_long4_rtz(half4);

long4 __ovld __cnfn convert_long4_sat(half4);

long4 __ovld __cnfn convert_long4_sat_rte(half4);

long4 __ovld __cnfn convert_long4_sat_rtp(half4);

long4 __ovld __cnfn convert_long4_sat_rtn(half4);

long4 __ovld __cnfn convert_long4_sat_rtz(half4);

long8 __ovld __cnfn convert_long8(half8);

long8 __ovld __cnfn convert_long8_rte(half8);

long8 __ovld __cnfn convert_long8_rtp(half8);

long8 __ovld __cnfn convert_long8_rtn(half8);

long8 __ovld __cnfn convert_long8_rtz(half8);

long8 __ovld __cnfn convert_long8_sat(half8);

long8 __ovld __cnfn convert_long8_sat_rte(half8);

long8 __ovld __cnfn convert_long8_sat_rtp(half8);

long8 __ovld __cnfn convert_long8_sat_rtn(half8);

long8 __ovld __cnfn convert_long8_sat_rtz(half8);

long16 __ovld __cnfn convert_long16(half16);

long16 __ovld __cnfn convert_long16_rte(half16);

long16 __ovld __cnfn convert_long16_rtp(half16);

long16 __ovld __cnfn convert_long16_rtn(half16);

long16 __ovld __cnfn convert_long16_rtz(half16);

long16 __ovld __cnfn convert_long16_sat(half16);

long16 __ovld __cnfn convert_long16_sat_rte(half16);

long16 __ovld __cnfn convert_long16_sat_rtp(half16);

long16 __ovld __cnfn convert_long16_sat_rtn(half16);

long16 __ovld __cnfn convert_long16_sat_rtz(half16);

float __ovld __cnfn convert_float(half);

float __ovld __cnfn convert_float_rte(half);

float __ovld __cnfn convert_float_rtp(half);

float __ovld __cnfn convert_float_rtn(half);

float __ovld __cnfn convert_float_rtz(half);

float2 __ovld __cnfn convert_float2(half2);

float2 __ovld __cnfn convert_float2_rte(half2);

float2 __ovld __cnfn convert_float2_rtp(half2);

float2 __ovld __cnfn convert_float2_rtn(half2);

float2 __ovld __cnfn convert_float2_rtz(half2);

float3 __ovld __cnfn convert_float3(half3);

float3 __ovld __cnfn convert_float3_rte(half3);

float3 __ovld __cnfn convert_float3_rtp(half3);

float3 __ovld __cnfn convert_float3_rtn(half3);

float3 __ovld __cnfn convert_float3_rtz(half3);

float4 __ovld __cnfn convert_float4(half4);

float4 __ovld __cnfn convert_float4_rte(half4);

float4 __ovld __cnfn convert_float4_rtp(half4);

float4 __ovld __cnfn convert_float4_rtn(half4);

float4 __ovld __cnfn convert_float4_rtz(half4);

float8 __ovld __cnfn convert_float8(half8);

float8 __ovld __cnfn convert_float8_rte(half8);

float8 __ovld __cnfn convert_float8_rtp(half8);

float8 __ovld __cnfn convert_float8_rtn(half8);

float8 __ovld __cnfn convert_float8_rtz(half8);

float16 __ovld __cnfn convert_float16(half16);

float16 __ovld __cnfn convert_float16_rte(half16);

float16 __ovld __cnfn convert_float16_rtp(half16);

float16 __ovld __cnfn convert_float16_rtn(half16);

float16 __ovld __cnfn convert_float16_rtz(half16);


// Convert non-double types to half types.

half __ovld __cnfn convert_half(uchar);

half __ovld __cnfn convert_half(ushort);

half __ovld __cnfn convert_half(uint);

half __ovld __cnfn convert_half(ulong);

half __ovld __cnfn convert_half(char);

half __ovld __cnfn convert_half(short);

half __ovld __cnfn convert_half(int);

half __ovld __cnfn convert_half(long);

half __ovld __cnfn convert_half(float);

half __ovld __cnfn convert_half(half);

half __ovld __cnfn convert_half_rte(uchar);

half __ovld __cnfn convert_half_rte(ushort);

half __ovld __cnfn convert_half_rte(uint);

half __ovld __cnfn convert_half_rte(ulong);

half __ovld __cnfn convert_half_rte(char);

half __ovld __cnfn convert_half_rte(short);

half __ovld __cnfn convert_half_rte(int);

half __ovld __cnfn convert_half_rte(long);

half __ovld __cnfn convert_half_rte(float);

half __ovld __cnfn convert_half_rte(half);

half __ovld __cnfn convert_half_rtp(uchar);

half __ovld __cnfn convert_half_rtp(ushort);

half __ovld __cnfn convert_half_rtp(uint);

half __ovld __cnfn convert_half_rtp(ulong);

half __ovld __cnfn convert_half_rtp(char);

half __ovld __cnfn convert_half_rtp(short);

half __ovld __cnfn convert_half_rtp(int);

half __ovld __cnfn convert_half_rtp(long);

half __ovld __cnfn convert_half_rtp(float);

half __ovld __cnfn convert_half_rtp(half);

half __ovld __cnfn convert_half_rtn(uchar);

half __ovld __cnfn convert_half_rtn(ushort);

half __ovld __cnfn convert_half_rtn(uint);

half __ovld __cnfn convert_half_rtn(ulong);

half __ovld __cnfn convert_half_rtn(char);

half __ovld __cnfn convert_half_rtn(short);

half __ovld __cnfn convert_half_rtn(int);

half __ovld __cnfn convert_half_rtn(long);

half __ovld __cnfn convert_half_rtn(float);

half __ovld __cnfn convert_half_rtn(half);

half __ovld __cnfn convert_half_rtz(uchar);

half __ovld __cnfn convert_half_rtz(ushort);

half __ovld __cnfn convert_half_rtz(uint);

half __ovld __cnfn convert_half_rtz(ulong);

half __ovld __cnfn convert_half_rtz(char);

half __ovld __cnfn convert_half_rtz(short);

half __ovld __cnfn convert_half_rtz(int);

half __ovld __cnfn convert_half_rtz(long);

half __ovld __cnfn convert_half_rtz(float);

half __ovld __cnfn convert_half_rtz(half);

half2 __ovld __cnfn convert_half2(char2);

half2 __ovld __cnfn convert_half2(uchar2);

half2 __ovld __cnfn convert_half2(short2);

half2 __ovld __cnfn convert_half2(ushort2);

half2 __ovld __cnfn convert_half2(int2);

half2 __ovld __cnfn convert_half2(uint2);

half2 __ovld __cnfn convert_half2(long2);

half2 __ovld __cnfn convert_half2(ulong2);

half2 __ovld __cnfn convert_half2(float2);

half2 __ovld __cnfn convert_half2(half2);

half2 __ovld __cnfn convert_half2_rte(char2);

half2 __ovld __cnfn convert_half2_rte(uchar2);

half2 __ovld __cnfn convert_half2_rte(short2);

half2 __ovld __cnfn convert_half2_rte(ushort2);

half2 __ovld __cnfn convert_half2_rte(int2);

half2 __ovld __cnfn convert_half2_rte(uint2);

half2 __ovld __cnfn convert_half2_rte(long2);

half2 __ovld __cnfn convert_half2_rte(ulong2);

half2 __ovld __cnfn convert_half2_rte(float2);

half2 __ovld __cnfn convert_half2_rte(half2);

half2 __ovld __cnfn convert_half2_rtp(char2);

half2 __ovld __cnfn convert_half2_rtp(uchar2);

half2 __ovld __cnfn convert_half2_rtp(short2);

half2 __ovld __cnfn convert_half2_rtp(ushort2);

half2 __ovld __cnfn convert_half2_rtp(int2);

half2 __ovld __cnfn convert_half2_rtp(uint2);

half2 __ovld __cnfn convert_half2_rtp(long2);

half2 __ovld __cnfn convert_half2_rtp(ulong2);

half2 __ovld __cnfn convert_half2_rtp(float2);

half2 __ovld __cnfn convert_half2_rtp(half2);

half2 __ovld __cnfn convert_half2_rtn(char2);

half2 __ovld __cnfn convert_half2_rtn(uchar2);

half2 __ovld __cnfn convert_half2_rtn(short2);

half2 __ovld __cnfn convert_half2_rtn(ushort2);

half2 __ovld __cnfn convert_half2_rtn(int2);

half2 __ovld __cnfn convert_half2_rtn(uint2);

half2 __ovld __cnfn convert_half2_rtn(long2);

half2 __ovld __cnfn convert_half2_rtn(ulong2);

half2 __ovld __cnfn convert_half2_rtn(float2);

half2 __ovld __cnfn convert_half2_rtn(half2);

half2 __ovld __cnfn convert_half2_rtz(char2);

half2 __ovld __cnfn convert_half2_rtz(uchar2);

half2 __ovld __cnfn convert_half2_rtz(short2);

half2 __ovld __cnfn convert_half2_rtz(ushort2);

half2 __ovld __cnfn convert_half2_rtz(int2);

half2 __ovld __cnfn convert_half2_rtz(uint2);

half2 __ovld __cnfn convert_half2_rtz(long2);

half2 __ovld __cnfn convert_half2_rtz(ulong2);

half2 __ovld __cnfn convert_half2_rtz(float2);

half2 __ovld __cnfn convert_half2_rtz(half2);

half3 __ovld __cnfn convert_half3(char3);

half3 __ovld __cnfn convert_half3(uchar3);

half3 __ovld __cnfn convert_half3(short3);

half3 __ovld __cnfn convert_half3(ushort3);

half3 __ovld __cnfn convert_half3(int3);

half3 __ovld __cnfn convert_half3(uint3);

half3 __ovld __cnfn convert_half3(long3);

half3 __ovld __cnfn convert_half3(ulong3);

half3 __ovld __cnfn convert_half3(float3);

half3 __ovld __cnfn convert_half3(half3);

half3 __ovld __cnfn convert_half3_rte(char3);

half3 __ovld __cnfn convert_half3_rte(uchar3);

half3 __ovld __cnfn convert_half3_rte(short3);

half3 __ovld __cnfn convert_half3_rte(ushort3);

half3 __ovld __cnfn convert_half3_rte(int3);

half3 __ovld __cnfn convert_half3_rte(uint3);

half3 __ovld __cnfn convert_half3_rte(long3);

half3 __ovld __cnfn convert_half3_rte(ulong3);

half3 __ovld __cnfn convert_half3_rte(float3);

half3 __ovld __cnfn convert_half3_rte(half3);

half3 __ovld __cnfn convert_half3_rtp(char3);

half3 __ovld __cnfn convert_half3_rtp(uchar3);

half3 __ovld __cnfn convert_half3_rtp(short3);

half3 __ovld __cnfn convert_half3_rtp(ushort3);

half3 __ovld __cnfn convert_half3_rtp(int3);

half3 __ovld __cnfn convert_half3_rtp(uint3);

half3 __ovld __cnfn convert_half3_rtp(long3);

half3 __ovld __cnfn convert_half3_rtp(ulong3);

half3 __ovld __cnfn convert_half3_rtp(float3);

half3 __ovld __cnfn convert_half3_rtp(half3);

half3 __ovld __cnfn convert_half3_rtn(char3);

half3 __ovld __cnfn convert_half3_rtn(uchar3);

half3 __ovld __cnfn convert_half3_rtn(short3);

half3 __ovld __cnfn convert_half3_rtn(ushort3);

half3 __ovld __cnfn convert_half3_rtn(int3);

half3 __ovld __cnfn convert_half3_rtn(uint3);

half3 __ovld __cnfn convert_half3_rtn(long3);

half3 __ovld __cnfn convert_half3_rtn(ulong3);

half3 __ovld __cnfn convert_half3_rtn(float3);

half3 __ovld __cnfn convert_half3_rtn(half3);

half3 __ovld __cnfn convert_half3_rtz(char3);

half3 __ovld __cnfn convert_half3_rtz(uchar3);

half3 __ovld __cnfn convert_half3_rtz(short3);

half3 __ovld __cnfn convert_half3_rtz(ushort3);

half3 __ovld __cnfn convert_half3_rtz(int3);

half3 __ovld __cnfn convert_half3_rtz(uint3);

half3 __ovld __cnfn convert_half3_rtz(long3);

half3 __ovld __cnfn convert_half3_rtz(ulong3);

half3 __ovld __cnfn convert_half3_rtz(float3);

half3 __ovld __cnfn convert_half3_rtz(half3);

half4 __ovld __cnfn convert_half4(char4);

half4 __ovld __cnfn convert_half4(uchar4);

half4 __ovld __cnfn convert_half4(short4);

half4 __ovld __cnfn convert_half4(ushort4);

half4 __ovld __cnfn convert_half4(int4);

half4 __ovld __cnfn convert_half4(uint4);

half4 __ovld __cnfn convert_half4(long4);

half4 __ovld __cnfn convert_half4(ulong4);

half4 __ovld __cnfn convert_half4(float4);

half4 __ovld __cnfn convert_half4(half4);

half4 __ovld __cnfn convert_half4_rte(char4);

half4 __ovld __cnfn convert_half4_rte(uchar4);

half4 __ovld __cnfn convert_half4_rte(short4);

half4 __ovld __cnfn convert_half4_rte(ushort4);

half4 __ovld __cnfn convert_half4_rte(int4);

half4 __ovld __cnfn convert_half4_rte(uint4);

half4 __ovld __cnfn convert_half4_rte(long4);

half4 __ovld __cnfn convert_half4_rte(ulong4);

half4 __ovld __cnfn convert_half4_rte(float4);

half4 __ovld __cnfn convert_half4_rte(half4);

half4 __ovld __cnfn convert_half4_rtp(char4);

half4 __ovld __cnfn convert_half4_rtp(uchar4);

half4 __ovld __cnfn convert_half4_rtp(short4);

half4 __ovld __cnfn convert_half4_rtp(ushort4);

half4 __ovld __cnfn convert_half4_rtp(int4);

half4 __ovld __cnfn convert_half4_rtp(uint4);

half4 __ovld __cnfn convert_half4_rtp(long4);

half4 __ovld __cnfn convert_half4_rtp(ulong4);

half4 __ovld __cnfn convert_half4_rtp(float4);

half4 __ovld __cnfn convert_half4_rtp(half4);

half4 __ovld __cnfn convert_half4_rtn(char4);

half4 __ovld __cnfn convert_half4_rtn(uchar4);

half4 __ovld __cnfn convert_half4_rtn(short4);

half4 __ovld __cnfn convert_half4_rtn(ushort4);

half4 __ovld __cnfn convert_half4_rtn(int4);

half4 __ovld __cnfn convert_half4_rtn(uint4);

half4 __ovld __cnfn convert_half4_rtn(long4);

half4 __ovld __cnfn convert_half4_rtn(ulong4);

half4 __ovld __cnfn convert_half4_rtn(float4);

half4 __ovld __cnfn convert_half4_rtn(half4);

half4 __ovld __cnfn convert_half4_rtz(char4);

half4 __ovld __cnfn convert_half4_rtz(uchar4);

half4 __ovld __cnfn convert_half4_rtz(short4);

half4 __ovld __cnfn convert_half4_rtz(ushort4);

half4 __ovld __cnfn convert_half4_rtz(int4);

half4 __ovld __cnfn convert_half4_rtz(uint4);

half4 __ovld __cnfn convert_half4_rtz(long4);

half4 __ovld __cnfn convert_half4_rtz(ulong4);

half4 __ovld __cnfn convert_half4_rtz(float4);

half4 __ovld __cnfn convert_half4_rtz(half4);

half8 __ovld __cnfn convert_half8(char8);

half8 __ovld __cnfn convert_half8(uchar8);

half8 __ovld __cnfn convert_half8(short8);

half8 __ovld __cnfn convert_half8(ushort8);

half8 __ovld __cnfn convert_half8(int8);

half8 __ovld __cnfn convert_half8(uint8);

half8 __ovld __cnfn convert_half8(long8);

half8 __ovld __cnfn convert_half8(ulong8);

half8 __ovld __cnfn convert_half8(float8);

half8 __ovld __cnfn convert_half8(half8);

half8 __ovld __cnfn convert_half8_rte(char8);

half8 __ovld __cnfn convert_half8_rte(uchar8);

half8 __ovld __cnfn convert_half8_rte(short8);

half8 __ovld __cnfn convert_half8_rte(ushort8);

half8 __ovld __cnfn convert_half8_rte(int8);

half8 __ovld __cnfn convert_half8_rte(uint8);

half8 __ovld __cnfn convert_half8_rte(long8);

half8 __ovld __cnfn convert_half8_rte(ulong8);

half8 __ovld __cnfn convert_half8_rte(float8);

half8 __ovld __cnfn convert_half8_rte(half8);

half8 __ovld __cnfn convert_half8_rtp(char8);

half8 __ovld __cnfn convert_half8_rtp(uchar8);

half8 __ovld __cnfn convert_half8_rtp(short8);

half8 __ovld __cnfn convert_half8_rtp(ushort8);

half8 __ovld __cnfn convert_half8_rtp(int8);

half8 __ovld __cnfn convert_half8_rtp(uint8);

half8 __ovld __cnfn convert_half8_rtp(long8);

half8 __ovld __cnfn convert_half8_rtp(ulong8);

half8 __ovld __cnfn convert_half8_rtp(float8);

half8 __ovld __cnfn convert_half8_rtp(half8);

half8 __ovld __cnfn convert_half8_rtn(char8);

half8 __ovld __cnfn convert_half8_rtn(uchar8);

half8 __ovld __cnfn convert_half8_rtn(short8);

half8 __ovld __cnfn convert_half8_rtn(ushort8);

half8 __ovld __cnfn convert_half8_rtn(int8);

half8 __ovld __cnfn convert_half8_rtn(uint8);

half8 __ovld __cnfn convert_half8_rtn(long8);

half8 __ovld __cnfn convert_half8_rtn(ulong8);

half8 __ovld __cnfn convert_half8_rtn(float8);

half8 __ovld __cnfn convert_half8_rtn(half8);

half8 __ovld __cnfn convert_half8_rtz(char8);

half8 __ovld __cnfn convert_half8_rtz(uchar8);

half8 __ovld __cnfn convert_half8_rtz(short8);

half8 __ovld __cnfn convert_half8_rtz(ushort8);

half8 __ovld __cnfn convert_half8_rtz(int8);

half8 __ovld __cnfn convert_half8_rtz(uint8);

half8 __ovld __cnfn convert_half8_rtz(long8);

half8 __ovld __cnfn convert_half8_rtz(ulong8);

half8 __ovld __cnfn convert_half8_rtz(float8);

half8 __ovld __cnfn convert_half8_rtz(half8);

half16 __ovld __cnfn convert_half16(char16);

half16 __ovld __cnfn convert_half16(uchar16);

half16 __ovld __cnfn convert_half16(short16);

half16 __ovld __cnfn convert_half16(ushort16);

half16 __ovld __cnfn convert_half16(int16);

half16 __ovld __cnfn convert_half16(uint16);

half16 __ovld __cnfn convert_half16(long16);

half16 __ovld __cnfn convert_half16(ulong16);

half16 __ovld __cnfn convert_half16(float16);

half16 __ovld __cnfn convert_half16(half16);

half16 __ovld __cnfn convert_half16_rte(char16);

half16 __ovld __cnfn convert_half16_rte(uchar16);

half16 __ovld __cnfn convert_half16_rte(short16);

half16 __ovld __cnfn convert_half16_rte(ushort16);

half16 __ovld __cnfn convert_half16_rte(int16);

half16 __ovld __cnfn convert_half16_rte(uint16);

half16 __ovld __cnfn convert_half16_rte(long16);

half16 __ovld __cnfn convert_half16_rte(ulong16);

half16 __ovld __cnfn convert_half16_rte(float16);

half16 __ovld __cnfn convert_half16_rte(half16);

half16 __ovld __cnfn convert_half16_rtp(char16);

half16 __ovld __cnfn convert_half16_rtp(uchar16);

half16 __ovld __cnfn convert_half16_rtp(short16);

half16 __ovld __cnfn convert_half16_rtp(ushort16);

half16 __ovld __cnfn convert_half16_rtp(int16);

half16 __ovld __cnfn convert_half16_rtp(uint16);

half16 __ovld __cnfn convert_half16_rtp(long16);

half16 __ovld __cnfn convert_half16_rtp(ulong16);

half16 __ovld __cnfn convert_half16_rtp(float16);

half16 __ovld __cnfn convert_half16_rtp(half16);

half16 __ovld __cnfn convert_half16_rtn(char16);

half16 __ovld __cnfn convert_half16_rtn(uchar16);

half16 __ovld __cnfn convert_half16_rtn(short16);

half16 __ovld __cnfn convert_half16_rtn(ushort16);

half16 __ovld __cnfn convert_half16_rtn(int16);

half16 __ovld __cnfn convert_half16_rtn(uint16);

half16 __ovld __cnfn convert_half16_rtn(long16);

half16 __ovld __cnfn convert_half16_rtn(ulong16);

half16 __ovld __cnfn convert_half16_rtn(float16);

half16 __ovld __cnfn convert_half16_rtn(half16);

half16 __ovld __cnfn convert_half16_rtz(char16);

half16 __ovld __cnfn convert_half16_rtz(uchar16);

half16 __ovld __cnfn convert_half16_rtz(short16);

half16 __ovld __cnfn convert_half16_rtz(ushort16);

half16 __ovld __cnfn convert_half16_rtz(int16);

half16 __ovld __cnfn convert_half16_rtz(uint16);

half16 __ovld __cnfn convert_half16_rtz(long16);

half16 __ovld __cnfn convert_half16_rtz(ulong16);

half16 __ovld __cnfn convert_half16_rtz(float16);

half16 __ovld __cnfn convert_half16_rtz(half16);


// Convert half types to double types.

#ifdef cl_khr_fp64

double __ovld __cnfn convert_double(half);

double __ovld __cnfn convert_double_rte(half);

double __ovld __cnfn convert_double_rtp(half);

double __ovld __cnfn convert_double_rtn(half);

double __ovld __cnfn convert_double_rtz(half);

double2 __ovld __cnfn convert_double2(half2);

double2 __ovld __cnfn convert_double2_rte(half2);

double2 __ovld __cnfn convert_double2_rtp(half2);

double2 __ovld __cnfn convert_double2_rtn(half2);

double2 __ovld __cnfn convert_double2_rtz(half2);

double3 __ovld __cnfn convert_double3(half3);

double3 __ovld __cnfn convert_double3_rte(half3);

double3 __ovld __cnfn convert_double3_rtp(half3);

double3 __ovld __cnfn convert_double3_rtn(half3);

double3 __ovld __cnfn convert_double3_rtz(half3);

double4 __ovld __cnfn convert_double4(half4);

double4 __ovld __cnfn convert_double4_rte(half4);

double4 __ovld __cnfn convert_double4_rtp(half4);

double4 __ovld __cnfn convert_double4_rtn(half4);

double4 __ovld __cnfn convert_double4_rtz(half4);

double8 __ovld __cnfn convert_double8(half8);

double8 __ovld __cnfn convert_double8_rte(half8);

double8 __ovld __cnfn convert_double8_rtp(half8);

double8 __ovld __cnfn convert_double8_rtn(half8);

double8 __ovld __cnfn convert_double8_rtz(half8);

double16 __ovld __cnfn convert_double16(half16);

double16 __ovld __cnfn convert_double16_rte(half16);

double16 __ovld __cnfn convert_double16_rtp(half16);

double16 __ovld __cnfn convert_double16_rtn(half16);

double16 __ovld __cnfn convert_double16_rtz(half16);


// Convert double types to half types.

half __ovld __cnfn convert_half(double);

half __ovld __cnfn convert_half_rte(double);

half __ovld __cnfn convert_half_rtp(double);

half __ovld __cnfn convert_half_rtn(double);

half __ovld __cnfn convert_half_rtz(double);

half2 __ovld __cnfn convert_half2(double2);

half2 __ovld __cnfn convert_half2_rte(double2);

half2 __ovld __cnfn convert_half2_rtp(double2);

half2 __ovld __cnfn convert_half2_rtn(double2);

half2 __ovld __cnfn convert_half2_rtz(double2);

half3 __ovld __cnfn convert_half3(double3);

half3 __ovld __cnfn convert_half3_rte(double3);

half3 __ovld __cnfn convert_half3_rtp(double3);

half3 __ovld __cnfn convert_half3_rtn(double3);

half3 __ovld __cnfn convert_half3_rtz(double3);

half4 __ovld __cnfn convert_half4(double4);

half4 __ovld __cnfn convert_half4_rte(double4);

half4 __ovld __cnfn convert_half4_rtp(double4);

half4 __ovld __cnfn convert_half4_rtn(double4);

half4 __ovld __cnfn convert_half4_rtz(double4);

half8 __ovld __cnfn convert_half8(double8);

half8 __ovld __cnfn convert_half8_rte(double8);

half8 __ovld __cnfn convert_half8_rtp(double8);

half8 __ovld __cnfn convert_half8_rtn(double8);

half8 __ovld __cnfn convert_half8_rtz(double8);

half16 __ovld __cnfn convert_half16(double16);

half16 __ovld __cnfn convert_half16_rte(double16);

half16 __ovld __cnfn convert_half16_rtp(double16);

half16 __ovld __cnfn convert_half16_rtn(double16);

half16 __ovld __cnfn convert_half16_rtz(double16);

#endif //cl_khr_fp64


#endif // cl_khr_fp16


#define as_char(x) __builtin_astype((x),   char)

#define as_char2(x) __builtin_astype((x),  char2)

#define as_char3(x) __builtin_astype((x),  char3)

#define as_char4(x) __builtin_astype((x),  char4)

#define as_char8(x) __builtin_astype((x),  char8)

#define as_char16(x) __builtin_astype((x), char16)


#define as_uchar(x) __builtin_astype((x),   uchar)

#define as_uchar2(x) __builtin_astype((x),  uchar2)

#define as_uchar3(x) __builtin_astype((x),  uchar3)

#define as_uchar4(x) __builtin_astype((x),  uchar4)

#define as_uchar8(x) __builtin_astype((x),  uchar8)

#define as_uchar16(x) __builtin_astype((x), uchar16)


#define as_short(x) __builtin_astype((x),   short)

#define as_short2(x) __builtin_astype((x),  short2)

#define as_short3(x) __builtin_astype((x),  short3)

#define as_short4(x) __builtin_astype((x),  short4)

#define as_short8(x) __builtin_astype((x),  short8)

#define as_short16(x) __builtin_astype((x), short16)


#define as_ushort(x) __builtin_astype((x),   ushort)

#define as_ushort2(x) __builtin_astype((x),  ushort2)

#define as_ushort3(x) __builtin_astype((x),  ushort3)

#define as_ushort4(x) __builtin_astype((x),  ushort4)

#define as_ushort8(x) __builtin_astype((x),  ushort8)

#define as_ushort16(x) __builtin_astype((x), ushort16)


#define as_int(x) __builtin_astype((x),   int)

#define as_int2(x) __builtin_astype((x),  int2)

#define as_int3(x) __builtin_astype((x),  int3)

#define as_int4(x) __builtin_astype((x),  int4)

#define as_int8(x) __builtin_astype((x),  int8)

#define as_int16(x) __builtin_astype((x), int16)


#define as_uint(x) __builtin_astype((x),   uint)

#define as_uint2(x) __builtin_astype((x),  uint2)

#define as_uint3(x) __builtin_astype((x),  uint3)

#define as_uint4(x) __builtin_astype((x),  uint4)

#define as_uint8(x) __builtin_astype((x),  uint8)

#define as_uint16(x) __builtin_astype((x), uint16)


#define as_long(x) __builtin_astype((x),   long)

#define as_long2(x) __builtin_astype((x),  long2)

#define as_long3(x) __builtin_astype((x),  long3)

#define as_long4(x) __builtin_astype((x),  long4)

#define as_long8(x) __builtin_astype((x),  long8)

#define as_long16(x) __builtin_astype((x), long16)


#define as_ulong(x) __builtin_astype((x),   ulong)

#define as_ulong2(x) __builtin_astype((x),  ulong2)

#define as_ulong3(x) __builtin_astype((x),  ulong3)

#define as_ulong4(x) __builtin_astype((x),  ulong4)

#define as_ulong8(x) __builtin_astype((x),  ulong8)

#define as_ulong16(x) __builtin_astype((x), ulong16)


#define as_float(x) __builtin_astype((x),   float)

#define as_float2(x) __builtin_astype((x),  float2)

#define as_float3(x) __builtin_astype((x),  float3)

#define as_float4(x) __builtin_astype((x),  float4)

#define as_float8(x) __builtin_astype((x),  float8)

#define as_float16(x) __builtin_astype((x), float16)


#ifdef cl_khr_fp64

#define as_double(x) __builtin_astype((x),   double)

#define as_double2(x) __builtin_astype((x),  double2)

#define as_double3(x) __builtin_astype((x),  double3)

#define as_double4(x) __builtin_astype((x),  double4)

#define as_double8(x) __builtin_astype((x),  double8)

#define as_double16(x) __builtin_astype((x), double16)

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

#define as_half(x) __builtin_astype((x),   half)

#define as_half2(x) __builtin_astype((x),  half2)

#define as_half3(x) __builtin_astype((x),  half3)

#define as_half4(x) __builtin_astype((x),  half4)

#define as_half8(x) __builtin_astype((x),  half8)

#define as_half16(x) __builtin_astype((x), half16)

#endif //cl_khr_fp16


// OpenCL v1.1 s6.9, v1.2/2.0 s6.10 - Function qualifiers


#define __kernel_exec(X, typen) __kernel \

        __attribute__((work_group_size_hint(X, 1, 1))) \

        __attribute__((vec_type_hint(typen)))

#define __kernel_exec(X, typen) __kernel \ …


#define kernel_exec(X, typen) __kernel \

        __attribute__((work_group_size_hint(X, 1, 1))) \

        __attribute__((vec_type_hint(typen)))

#define kernel_exec(X, typen) __kernel \ …


// OpenCL v1.1 s6.11.1, v1.2 s6.12.1, v2.0 s6.13.1 - Work-item Functions


uint __ovld __cnfn get_work_dim(void);


size_t __ovld __cnfn get_global_size(uint dimindx);


size_t __ovld __cnfn get_global_id(uint dimindx);


size_t __ovld __cnfn get_local_size(uint dimindx);


size_t __ovld __cnfn get_local_id(uint dimindx);


size_t __ovld __cnfn get_num_groups(uint dimindx);


size_t __ovld __cnfn get_group_id(uint dimindx);


size_t __ovld __cnfn get_global_offset(uint dimindx);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

size_t __ovld get_enqueued_local_size(uint dimindx);

size_t __ovld get_global_linear_id(void);

size_t __ovld get_local_linear_id(void);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v1.1 s6.11.2, v1.2 s6.12.2, v2.0 s6.13.2 - Math functions


float __ovld __cnfn acos(float);

float2 __ovld __cnfn acos(float2);

float3 __ovld __cnfn acos(float3);

float4 __ovld __cnfn acos(float4);

float8 __ovld __cnfn acos(float8);

float16 __ovld __cnfn acos(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn acos(double);

double2 __ovld __cnfn acos(double2);

double3 __ovld __cnfn acos(double3);

double4 __ovld __cnfn acos(double4);

double8 __ovld __cnfn acos(double8);

double16 __ovld __cnfn acos(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn acos(half);

half2 __ovld __cnfn acos(half2);

half3 __ovld __cnfn acos(half3);

half4 __ovld __cnfn acos(half4);

half8 __ovld __cnfn acos(half8);

half16 __ovld __cnfn acos(half16);

#endif //cl_khr_fp16


float __ovld __cnfn acosh(float);

float2 __ovld __cnfn acosh(float2);

float3 __ovld __cnfn acosh(float3);

float4 __ovld __cnfn acosh(float4);

float8 __ovld __cnfn acosh(float8);

float16 __ovld __cnfn acosh(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn acosh(double);

double2 __ovld __cnfn acosh(double2);

double3 __ovld __cnfn acosh(double3);

double4 __ovld __cnfn acosh(double4);

double8 __ovld __cnfn acosh(double8);

double16 __ovld __cnfn acosh(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn acosh(half);

half2 __ovld __cnfn acosh(half2);

half3 __ovld __cnfn acosh(half3);

half4 __ovld __cnfn acosh(half4);

half8 __ovld __cnfn acosh(half8);

half16 __ovld __cnfn acosh(half16);

#endif //cl_khr_fp16


float __ovld __cnfn acospi(float x);

float2 __ovld __cnfn acospi(float2 x);

float3 __ovld __cnfn acospi(float3 x);

float4 __ovld __cnfn acospi(float4 x);

float8 __ovld __cnfn acospi(float8 x);

float16 __ovld __cnfn acospi(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn acospi(double x);

double2 __ovld __cnfn acospi(double2 x);

double3 __ovld __cnfn acospi(double3 x);

double4 __ovld __cnfn acospi(double4 x);

double8 __ovld __cnfn acospi(double8 x);

double16 __ovld __cnfn acospi(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn acospi(half x);

half2 __ovld __cnfn acospi(half2 x);

half3 __ovld __cnfn acospi(half3 x);

half4 __ovld __cnfn acospi(half4 x);

half8 __ovld __cnfn acospi(half8 x);

half16 __ovld __cnfn acospi(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn asin(float);

float2 __ovld __cnfn asin(float2);

float3 __ovld __cnfn asin(float3);

float4 __ovld __cnfn asin(float4);

float8 __ovld __cnfn asin(float8);

float16 __ovld __cnfn asin(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn asin(double);

double2 __ovld __cnfn asin(double2);

double3 __ovld __cnfn asin(double3);

double4 __ovld __cnfn asin(double4);

double8 __ovld __cnfn asin(double8);

double16 __ovld __cnfn asin(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn asin(half);

half2 __ovld __cnfn asin(half2);

half3 __ovld __cnfn asin(half3);

half4 __ovld __cnfn asin(half4);

half8 __ovld __cnfn asin(half8);

half16 __ovld __cnfn asin(half16);

#endif //cl_khr_fp16


float __ovld __cnfn asinh(float);

float2 __ovld __cnfn asinh(float2);

float3 __ovld __cnfn asinh(float3);

float4 __ovld __cnfn asinh(float4);

float8 __ovld __cnfn asinh(float8);

float16 __ovld __cnfn asinh(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn asinh(double);

double2 __ovld __cnfn asinh(double2);

double3 __ovld __cnfn asinh(double3);

double4 __ovld __cnfn asinh(double4);

double8 __ovld __cnfn asinh(double8);

double16 __ovld __cnfn asinh(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn asinh(half);

half2 __ovld __cnfn asinh(half2);

half3 __ovld __cnfn asinh(half3);

half4 __ovld __cnfn asinh(half4);

half8 __ovld __cnfn asinh(half8);

half16 __ovld __cnfn asinh(half16);

#endif //cl_khr_fp16


float __ovld __cnfn asinpi(float x);

float2 __ovld __cnfn asinpi(float2 x);

float3 __ovld __cnfn asinpi(float3 x);

float4 __ovld __cnfn asinpi(float4 x);

float8 __ovld __cnfn asinpi(float8 x);

float16 __ovld __cnfn asinpi(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn asinpi(double x);

double2 __ovld __cnfn asinpi(double2 x);

double3 __ovld __cnfn asinpi(double3 x);

double4 __ovld __cnfn asinpi(double4 x);

double8 __ovld __cnfn asinpi(double8 x);

double16 __ovld __cnfn asinpi(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn asinpi(half x);

half2 __ovld __cnfn asinpi(half2 x);

half3 __ovld __cnfn asinpi(half3 x);

half4 __ovld __cnfn asinpi(half4 x);

half8 __ovld __cnfn asinpi(half8 x);

half16 __ovld __cnfn asinpi(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn atan(float y_over_x);

float2 __ovld __cnfn atan(float2 y_over_x);

float3 __ovld __cnfn atan(float3 y_over_x);

float4 __ovld __cnfn atan(float4 y_over_x);

float8 __ovld __cnfn atan(float8 y_over_x);

float16 __ovld __cnfn atan(float16 y_over_x);

#ifdef cl_khr_fp64

double __ovld __cnfn atan(double y_over_x);

double2 __ovld __cnfn atan(double2 y_over_x);

double3 __ovld __cnfn atan(double3 y_over_x);

double4 __ovld __cnfn atan(double4 y_over_x);

double8 __ovld __cnfn atan(double8 y_over_x);

double16 __ovld __cnfn atan(double16 y_over_x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn atan(half y_over_x);

half2 __ovld __cnfn atan(half2 y_over_x);

half3 __ovld __cnfn atan(half3 y_over_x);

half4 __ovld __cnfn atan(half4 y_over_x);

half8 __ovld __cnfn atan(half8 y_over_x);

half16 __ovld __cnfn atan(half16 y_over_x);

#endif //cl_khr_fp16


float __ovld __cnfn atan2(float y, float x);

float2 __ovld __cnfn atan2(float2 y, float2 x);

float3 __ovld __cnfn atan2(float3 y, float3 x);

float4 __ovld __cnfn atan2(float4 y, float4 x);

float8 __ovld __cnfn atan2(float8 y, float8 x);

float16 __ovld __cnfn atan2(float16 y, float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn atan2(double y, double x);

double2 __ovld __cnfn atan2(double2 y, double2 x);

double3 __ovld __cnfn atan2(double3 y, double3 x);

double4 __ovld __cnfn atan2(double4 y, double4 x);

double8 __ovld __cnfn atan2(double8 y, double8 x);

double16 __ovld __cnfn atan2(double16 y, double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn atan2(half y, half x);

half2 __ovld __cnfn atan2(half2 y, half2 x);

half3 __ovld __cnfn atan2(half3 y, half3 x);

half4 __ovld __cnfn atan2(half4 y, half4 x);

half8 __ovld __cnfn atan2(half8 y, half8 x);

half16 __ovld __cnfn atan2(half16 y, half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn atanh(float);

float2 __ovld __cnfn atanh(float2);

float3 __ovld __cnfn atanh(float3);

float4 __ovld __cnfn atanh(float4);

float8 __ovld __cnfn atanh(float8);

float16 __ovld __cnfn atanh(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn atanh(double);

double2 __ovld __cnfn atanh(double2);

double3 __ovld __cnfn atanh(double3);

double4 __ovld __cnfn atanh(double4);

double8 __ovld __cnfn atanh(double8);

double16 __ovld __cnfn atanh(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn atanh(half);

half2 __ovld __cnfn atanh(half2);

half3 __ovld __cnfn atanh(half3);

half4 __ovld __cnfn atanh(half4);

half8 __ovld __cnfn atanh(half8);

half16 __ovld __cnfn atanh(half16);

#endif //cl_khr_fp16


float __ovld __cnfn atanpi(float x);

float2 __ovld __cnfn atanpi(float2 x);

float3 __ovld __cnfn atanpi(float3 x);

float4 __ovld __cnfn atanpi(float4 x);

float8 __ovld __cnfn atanpi(float8 x);

float16 __ovld __cnfn atanpi(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn atanpi(double x);

double2 __ovld __cnfn atanpi(double2 x);

double3 __ovld __cnfn atanpi(double3 x);

double4 __ovld __cnfn atanpi(double4 x);

double8 __ovld __cnfn atanpi(double8 x);

double16 __ovld __cnfn atanpi(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn atanpi(half x);

half2 __ovld __cnfn atanpi(half2 x);

half3 __ovld __cnfn atanpi(half3 x);

half4 __ovld __cnfn atanpi(half4 x);

half8 __ovld __cnfn atanpi(half8 x);

half16 __ovld __cnfn atanpi(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn atan2pi(float y, float x);

float2 __ovld __cnfn atan2pi(float2 y, float2 x);

float3 __ovld __cnfn atan2pi(float3 y, float3 x);

float4 __ovld __cnfn atan2pi(float4 y, float4 x);

float8 __ovld __cnfn atan2pi(float8 y, float8 x);

float16 __ovld __cnfn atan2pi(float16 y, float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn atan2pi(double y, double x);

double2 __ovld __cnfn atan2pi(double2 y, double2 x);

double3 __ovld __cnfn atan2pi(double3 y, double3 x);

double4 __ovld __cnfn atan2pi(double4 y, double4 x);

double8 __ovld __cnfn atan2pi(double8 y, double8 x);

double16 __ovld __cnfn atan2pi(double16 y, double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn atan2pi(half y, half x);

half2 __ovld __cnfn atan2pi(half2 y, half2 x);

half3 __ovld __cnfn atan2pi(half3 y, half3 x);

half4 __ovld __cnfn atan2pi(half4 y, half4 x);

half8 __ovld __cnfn atan2pi(half8 y, half8 x);

half16 __ovld __cnfn atan2pi(half16 y, half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn cbrt(float);

float2 __ovld __cnfn cbrt(float2);

float3 __ovld __cnfn cbrt(float3);

float4 __ovld __cnfn cbrt(float4);

float8 __ovld __cnfn cbrt(float8);

float16 __ovld __cnfn cbrt(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn cbrt(double);

double2 __ovld __cnfn cbrt(double2);

double3 __ovld __cnfn cbrt(double3);

double4 __ovld __cnfn cbrt(double4);

double8 __ovld __cnfn cbrt(double8);

double16 __ovld __cnfn cbrt(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn cbrt(half);

half2 __ovld __cnfn cbrt(half2);

half3 __ovld __cnfn cbrt(half3);

half4 __ovld __cnfn cbrt(half4);

half8 __ovld __cnfn cbrt(half8);

half16 __ovld __cnfn cbrt(half16);

#endif //cl_khr_fp16


float __ovld __cnfn ceil(float);

float2 __ovld __cnfn ceil(float2);

float3 __ovld __cnfn ceil(float3);

float4 __ovld __cnfn ceil(float4);

float8 __ovld __cnfn ceil(float8);

float16 __ovld __cnfn ceil(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn ceil(double);

double2 __ovld __cnfn ceil(double2);

double3 __ovld __cnfn ceil(double3);

double4 __ovld __cnfn ceil(double4);

double8 __ovld __cnfn ceil(double8);

double16 __ovld __cnfn ceil(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn ceil(half);

half2 __ovld __cnfn ceil(half2);

half3 __ovld __cnfn ceil(half3);

half4 __ovld __cnfn ceil(half4);

half8 __ovld __cnfn ceil(half8);

half16 __ovld __cnfn ceil(half16);

#endif //cl_khr_fp16


float __ovld __cnfn copysign(float x, float y);

float2 __ovld __cnfn copysign(float2 x, float2 y);

float3 __ovld __cnfn copysign(float3 x, float3 y);

float4 __ovld __cnfn copysign(float4 x, float4 y);

float8 __ovld __cnfn copysign(float8 x, float8 y);

float16 __ovld __cnfn copysign(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn copysign(double x, double y);

double2 __ovld __cnfn copysign(double2 x, double2 y);

double3 __ovld __cnfn copysign(double3 x, double3 y);

double4 __ovld __cnfn copysign(double4 x, double4 y);

double8 __ovld __cnfn copysign(double8 x, double8 y);

double16 __ovld __cnfn copysign(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn copysign(half x, half y);

half2 __ovld __cnfn copysign(half2 x, half2 y);

half3 __ovld __cnfn copysign(half3 x, half3 y);

half4 __ovld __cnfn copysign(half4 x, half4 y);

half8 __ovld __cnfn copysign(half8 x, half8 y);

half16 __ovld __cnfn copysign(half16 x, half16 y);

#endif //cl_khr_fp16


float __ovld __cnfn cos(float);

float2 __ovld __cnfn cos(float2);

float3 __ovld __cnfn cos(float3);

float4 __ovld __cnfn cos(float4);

float8 __ovld __cnfn cos(float8);

float16 __ovld __cnfn cos(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn cos(double);

double2 __ovld __cnfn cos(double2);

double3 __ovld __cnfn cos(double3);

double4 __ovld __cnfn cos(double4);

double8 __ovld __cnfn cos(double8);

double16 __ovld __cnfn cos(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn cos(half);

half2 __ovld __cnfn cos(half2);

half3 __ovld __cnfn cos(half3);

half4 __ovld __cnfn cos(half4);

half8 __ovld __cnfn cos(half8);

half16 __ovld __cnfn cos(half16);

#endif //cl_khr_fp16


float __ovld __cnfn cosh(float);

float2 __ovld __cnfn cosh(float2);

float3 __ovld __cnfn cosh(float3);

float4 __ovld __cnfn cosh(float4);

float8 __ovld __cnfn cosh(float8);

float16 __ovld __cnfn cosh(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn cosh(double);

double2 __ovld __cnfn cosh(double2);

double3 __ovld __cnfn cosh(double3);

double4 __ovld __cnfn cosh(double4);

double8 __ovld __cnfn cosh(double8);

double16 __ovld __cnfn cosh(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn cosh(half);

half2 __ovld __cnfn cosh(half2);

half3 __ovld __cnfn cosh(half3);

half4 __ovld __cnfn cosh(half4);

half8 __ovld __cnfn cosh(half8);

half16 __ovld __cnfn cosh(half16);

#endif //cl_khr_fp16


float __ovld __cnfn cospi(float x);

float2 __ovld __cnfn cospi(float2 x);

float3 __ovld __cnfn cospi(float3 x);

float4 __ovld __cnfn cospi(float4 x);

float8 __ovld __cnfn cospi(float8 x);

float16 __ovld __cnfn cospi(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn cospi(double x);

double2 __ovld __cnfn cospi(double2 x);

double3 __ovld __cnfn cospi(double3 x);

double4 __ovld __cnfn cospi(double4 x);

double8 __ovld __cnfn cospi(double8 x);

double16 __ovld __cnfn cospi(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn cospi(half x);

half2 __ovld __cnfn cospi(half2 x);

half3 __ovld __cnfn cospi(half3 x);

half4 __ovld __cnfn cospi(half4 x);

half8 __ovld __cnfn cospi(half8 x);

half16 __ovld __cnfn cospi(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn erfc(float);

float2 __ovld __cnfn erfc(float2);

float3 __ovld __cnfn erfc(float3);

float4 __ovld __cnfn erfc(float4);

float8 __ovld __cnfn erfc(float8);

float16 __ovld __cnfn erfc(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn erfc(double);

double2 __ovld __cnfn erfc(double2);

double3 __ovld __cnfn erfc(double3);

double4 __ovld __cnfn erfc(double4);

double8 __ovld __cnfn erfc(double8);

double16 __ovld __cnfn erfc(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn erfc(half);

half2 __ovld __cnfn erfc(half2);

half3 __ovld __cnfn erfc(half3);

half4 __ovld __cnfn erfc(half4);

half8 __ovld __cnfn erfc(half8);

half16 __ovld __cnfn erfc(half16);

#endif //cl_khr_fp16


float __ovld __cnfn erf(float);

float2 __ovld __cnfn erf(float2);

float3 __ovld __cnfn erf(float3);

float4 __ovld __cnfn erf(float4);

float8 __ovld __cnfn erf(float8);

float16 __ovld __cnfn erf(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn erf(double);

double2 __ovld __cnfn erf(double2);

double3 __ovld __cnfn erf(double3);

double4 __ovld __cnfn erf(double4);

double8 __ovld __cnfn erf(double8);

double16 __ovld __cnfn erf(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn erf(half);

half2 __ovld __cnfn erf(half2);

half3 __ovld __cnfn erf(half3);

half4 __ovld __cnfn erf(half4);

half8 __ovld __cnfn erf(half8);

half16 __ovld __cnfn erf(half16);

#endif //cl_khr_fp16


float __ovld __cnfn exp(float x);

float2 __ovld __cnfn exp(float2 x);

float3 __ovld __cnfn exp(float3 x);

float4 __ovld __cnfn exp(float4 x);

float8 __ovld __cnfn exp(float8 x);

float16 __ovld __cnfn exp(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn exp(double x);

double2 __ovld __cnfn exp(double2 x);

double3 __ovld __cnfn exp(double3 x);

double4 __ovld __cnfn exp(double4 x);

double8 __ovld __cnfn exp(double8 x);

double16 __ovld __cnfn exp(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn exp(half x);

half2 __ovld __cnfn exp(half2 x);

half3 __ovld __cnfn exp(half3 x);

half4 __ovld __cnfn exp(half4 x);

half8 __ovld __cnfn exp(half8 x);

half16 __ovld __cnfn exp(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn exp2(float);

float2 __ovld __cnfn exp2(float2);

float3 __ovld __cnfn exp2(float3);

float4 __ovld __cnfn exp2(float4);

float8 __ovld __cnfn exp2(float8);

float16 __ovld __cnfn exp2(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn exp2(double);

double2 __ovld __cnfn exp2(double2);

double3 __ovld __cnfn exp2(double3);

double4 __ovld __cnfn exp2(double4);

double8 __ovld __cnfn exp2(double8);

double16 __ovld __cnfn exp2(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn exp2(half);

half2 __ovld __cnfn exp2(half2);

half3 __ovld __cnfn exp2(half3);

half4 __ovld __cnfn exp2(half4);

half8 __ovld __cnfn exp2(half8);

half16 __ovld __cnfn exp2(half16);

#endif //cl_khr_fp16


float __ovld __cnfn exp10(float);

float2 __ovld __cnfn exp10(float2);

float3 __ovld __cnfn exp10(float3);

float4 __ovld __cnfn exp10(float4);

float8 __ovld __cnfn exp10(float8);

float16 __ovld __cnfn exp10(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn exp10(double);

double2 __ovld __cnfn exp10(double2);

double3 __ovld __cnfn exp10(double3);

double4 __ovld __cnfn exp10(double4);

double8 __ovld __cnfn exp10(double8);

double16 __ovld __cnfn exp10(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn exp10(half);

half2 __ovld __cnfn exp10(half2);

half3 __ovld __cnfn exp10(half3);

half4 __ovld __cnfn exp10(half4);

half8 __ovld __cnfn exp10(half8);

half16 __ovld __cnfn exp10(half16);

#endif //cl_khr_fp16


float __ovld __cnfn expm1(float x);

float2 __ovld __cnfn expm1(float2 x);

float3 __ovld __cnfn expm1(float3 x);

float4 __ovld __cnfn expm1(float4 x);

float8 __ovld __cnfn expm1(float8 x);

float16 __ovld __cnfn expm1(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn expm1(double x);

double2 __ovld __cnfn expm1(double2 x);

double3 __ovld __cnfn expm1(double3 x);

double4 __ovld __cnfn expm1(double4 x);

double8 __ovld __cnfn expm1(double8 x);

double16 __ovld __cnfn expm1(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn expm1(half x);

half2 __ovld __cnfn expm1(half2 x);

half3 __ovld __cnfn expm1(half3 x);

half4 __ovld __cnfn expm1(half4 x);

half8 __ovld __cnfn expm1(half8 x);

half16 __ovld __cnfn expm1(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn fabs(float);

float2 __ovld __cnfn fabs(float2);

float3 __ovld __cnfn fabs(float3);

float4 __ovld __cnfn fabs(float4);

float8 __ovld __cnfn fabs(float8);

float16 __ovld __cnfn fabs(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn fabs(double);

double2 __ovld __cnfn fabs(double2);

double3 __ovld __cnfn fabs(double3);

double4 __ovld __cnfn fabs(double4);

double8 __ovld __cnfn fabs(double8);

double16 __ovld __cnfn fabs(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn fabs(half);

half2 __ovld __cnfn fabs(half2);

half3 __ovld __cnfn fabs(half3);

half4 __ovld __cnfn fabs(half4);

half8 __ovld __cnfn fabs(half8);

half16 __ovld __cnfn fabs(half16);

#endif //cl_khr_fp16


float __ovld __cnfn fdim(float x, float y);

float2 __ovld __cnfn fdim(float2 x, float2 y);

float3 __ovld __cnfn fdim(float3 x, float3 y);

float4 __ovld __cnfn fdim(float4 x, float4 y);

float8 __ovld __cnfn fdim(float8 x, float8 y);

float16 __ovld __cnfn fdim(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn fdim(double x, double y);

double2 __ovld __cnfn fdim(double2 x, double2 y);

double3 __ovld __cnfn fdim(double3 x, double3 y);

double4 __ovld __cnfn fdim(double4 x, double4 y);

double8 __ovld __cnfn fdim(double8 x, double8 y);

double16 __ovld __cnfn fdim(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn fdim(half x, half y);

half2 __ovld __cnfn fdim(half2 x, half2 y);

half3 __ovld __cnfn fdim(half3 x, half3 y);

half4 __ovld __cnfn fdim(half4 x, half4 y);

half8 __ovld __cnfn fdim(half8 x, half8 y);

half16 __ovld __cnfn fdim(half16 x, half16 y);

#endif //cl_khr_fp16


float __ovld __cnfn floor(float);

float2 __ovld __cnfn floor(float2);

float3 __ovld __cnfn floor(float3);

float4 __ovld __cnfn floor(float4);

float8 __ovld __cnfn floor(float8);

float16 __ovld __cnfn floor(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn floor(double);

double2 __ovld __cnfn floor(double2);

double3 __ovld __cnfn floor(double3);

double4 __ovld __cnfn floor(double4);

double8 __ovld __cnfn floor(double8);

double16 __ovld __cnfn floor(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn floor(half);

half2 __ovld __cnfn floor(half2);

half3 __ovld __cnfn floor(half3);

half4 __ovld __cnfn floor(half4);

half8 __ovld __cnfn floor(half8);

half16 __ovld __cnfn floor(half16);

#endif //cl_khr_fp16


float __ovld __cnfn fma(float a, float b, float c);

float2 __ovld __cnfn fma(float2 a, float2 b, float2 c);

float3 __ovld __cnfn fma(float3 a, float3 b, float3 c);

float4 __ovld __cnfn fma(float4 a, float4 b, float4 c);

float8 __ovld __cnfn fma(float8 a, float8 b, float8 c);

float16 __ovld __cnfn fma(float16 a, float16 b, float16 c);

#ifdef cl_khr_fp64

double __ovld __cnfn fma(double a, double b, double c);

double2 __ovld __cnfn fma(double2 a, double2 b, double2 c);

double3 __ovld __cnfn fma(double3 a, double3 b, double3 c);

double4 __ovld __cnfn fma(double4 a, double4 b, double4 c);

double8 __ovld __cnfn fma(double8 a, double8 b, double8 c);

double16 __ovld __cnfn fma(double16 a, double16 b, double16 c);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn fma(half a, half b, half c);

half2 __ovld __cnfn fma(half2 a, half2 b, half2 c);

half3 __ovld __cnfn fma(half3 a, half3 b, half3 c);

half4 __ovld __cnfn fma(half4 a, half4 b, half4 c);

half8 __ovld __cnfn fma(half8 a, half8 b, half8 c);

half16 __ovld __cnfn fma(half16 a, half16 b, half16 c);

#endif //cl_khr_fp16


float __ovld __cnfn fmax(float x, float y);

float2 __ovld __cnfn fmax(float2 x, float2 y);

float3 __ovld __cnfn fmax(float3 x, float3 y);

float4 __ovld __cnfn fmax(float4 x, float4 y);

float8 __ovld __cnfn fmax(float8 x, float8 y);

float16 __ovld __cnfn fmax(float16 x, float16 y);

float2 __ovld __cnfn fmax(float2 x, float y);

float3 __ovld __cnfn fmax(float3 x, float y);

float4 __ovld __cnfn fmax(float4 x, float y);

float8 __ovld __cnfn fmax(float8 x, float y);

float16 __ovld __cnfn fmax(float16 x, float y);

#ifdef cl_khr_fp64

double __ovld __cnfn fmax(double x, double y);

double2 __ovld __cnfn fmax(double2 x, double2 y);

double3 __ovld __cnfn fmax(double3 x, double3 y);

double4 __ovld __cnfn fmax(double4 x, double4 y);

double8 __ovld __cnfn fmax(double8 x, double8 y);

double16 __ovld __cnfn fmax(double16 x, double16 y);

double2 __ovld __cnfn fmax(double2 x, double y);

double3 __ovld __cnfn fmax(double3 x, double y);

double4 __ovld __cnfn fmax(double4 x, double y);

double8 __ovld __cnfn fmax(double8 x, double y);

double16 __ovld __cnfn fmax(double16 x, double y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn fmax(half x, half y);

half2 __ovld __cnfn fmax(half2 x, half2 y);

half3 __ovld __cnfn fmax(half3 x, half3 y);

half4 __ovld __cnfn fmax(half4 x, half4 y);

half8 __ovld __cnfn fmax(half8 x, half8 y);

half16 __ovld __cnfn fmax(half16 x, half16 y);

half2 __ovld __cnfn fmax(half2 x, half y);

half3 __ovld __cnfn fmax(half3 x, half y);

half4 __ovld __cnfn fmax(half4 x, half y);

half8 __ovld __cnfn fmax(half8 x, half y);

half16 __ovld __cnfn fmax(half16 x, half y);

#endif //cl_khr_fp16


float __ovld __cnfn fmin(float x, float y);

float2 __ovld __cnfn fmin(float2 x, float2 y);

float3 __ovld __cnfn fmin(float3 x, float3 y);

float4 __ovld __cnfn fmin(float4 x, float4 y);

float8 __ovld __cnfn fmin(float8 x, float8 y);

float16 __ovld __cnfn fmin(float16 x, float16 y);

float2 __ovld __cnfn fmin(float2 x, float y);

float3 __ovld __cnfn fmin(float3 x, float y);

float4 __ovld __cnfn fmin(float4 x, float y);

float8 __ovld __cnfn fmin(float8 x, float y);

float16 __ovld __cnfn fmin(float16 x, float y);

#ifdef cl_khr_fp64

double __ovld __cnfn fmin(double x, double y);

double2 __ovld __cnfn fmin(double2 x, double2 y);

double3 __ovld __cnfn fmin(double3 x, double3 y);

double4 __ovld __cnfn fmin(double4 x, double4 y);

double8 __ovld __cnfn fmin(double8 x, double8 y);

double16 __ovld __cnfn fmin(double16 x, double16 y);

double2 __ovld __cnfn fmin(double2 x, double y);

double3 __ovld __cnfn fmin(double3 x, double y);

double4 __ovld __cnfn fmin(double4 x, double y);

double8 __ovld __cnfn fmin(double8 x, double y);

double16 __ovld __cnfn fmin(double16 x, double y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn fmin(half x, half y);

half2 __ovld __cnfn fmin(half2 x, half2 y);

half3 __ovld __cnfn fmin(half3 x, half3 y);

half4 __ovld __cnfn fmin(half4 x, half4 y);

half8 __ovld __cnfn fmin(half8 x, half8 y);

half16 __ovld __cnfn fmin(half16 x, half16 y);

half2 __ovld __cnfn fmin(half2 x, half y);

half3 __ovld __cnfn fmin(half3 x, half y);

half4 __ovld __cnfn fmin(half4 x, half y);

half8 __ovld __cnfn fmin(half8 x, half y);

half16 __ovld __cnfn fmin(half16 x, half y);

#endif //cl_khr_fp16


float __ovld __cnfn fmod(float x, float y);

float2 __ovld __cnfn fmod(float2 x, float2 y);

float3 __ovld __cnfn fmod(float3 x, float3 y);

float4 __ovld __cnfn fmod(float4 x, float4 y);

float8 __ovld __cnfn fmod(float8 x, float8 y);

float16 __ovld __cnfn fmod(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn fmod(double x, double y);

double2 __ovld __cnfn fmod(double2 x, double2 y);

double3 __ovld __cnfn fmod(double3 x, double3 y);

double4 __ovld __cnfn fmod(double4 x, double4 y);

double8 __ovld __cnfn fmod(double8 x, double8 y);

double16 __ovld __cnfn fmod(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn fmod(half x, half y);

half2 __ovld __cnfn fmod(half2 x, half2 y);

half3 __ovld __cnfn fmod(half3 x, half3 y);

half4 __ovld __cnfn fmod(half4 x, half4 y);

half8 __ovld __cnfn fmod(half8 x, half8 y);

half16 __ovld __cnfn fmod(half16 x, half16 y);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld fract(float x, float *iptr);

float2 __ovld fract(float2 x, float2 *iptr);

float3 __ovld fract(float3 x, float3 *iptr);

float4 __ovld fract(float4 x, float4 *iptr);

float8 __ovld fract(float8 x, float8 *iptr);

float16 __ovld fract(float16 x, float16 *iptr);

#ifdef cl_khr_fp64

double __ovld fract(double x, double *iptr);

double2 __ovld fract(double2 x, double2 *iptr);

double3 __ovld fract(double3 x, double3 *iptr);

double4 __ovld fract(double4 x, double4 *iptr);

double8 __ovld fract(double8 x, double8 *iptr);

double16 __ovld fract(double16 x, double16 *iptr);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld fract(half x, half *iptr);

half2 __ovld fract(half2 x, half2 *iptr);

half3 __ovld fract(half3 x, half3 *iptr);

half4 __ovld fract(half4 x, half4 *iptr);

half8 __ovld fract(half8 x, half8 *iptr);

half16 __ovld fract(half16 x, half16 *iptr);

#endif //cl_khr_fp16

#else

float __ovld fract(float x, __global float *iptr);

float2 __ovld fract(float2 x, __global float2 *iptr);

float3 __ovld fract(float3 x, __global float3 *iptr);

float4 __ovld fract(float4 x, __global float4 *iptr);

float8 __ovld fract(float8 x, __global float8 *iptr);

float16 __ovld fract(float16 x, __global float16 *iptr);

float __ovld fract(float x, __local float *iptr);

float2 __ovld fract(float2 x, __local float2 *iptr);

float3 __ovld fract(float3 x, __local float3 *iptr);

float4 __ovld fract(float4 x, __local float4 *iptr);

float8 __ovld fract(float8 x, __local float8 *iptr);

float16 __ovld fract(float16 x, __local float16 *iptr);

float __ovld fract(float x, __private float *iptr);

float2 __ovld fract(float2 x, __private float2 *iptr);

float3 __ovld fract(float3 x, __private float3 *iptr);

float4 __ovld fract(float4 x, __private float4 *iptr);

float8 __ovld fract(float8 x, __private float8 *iptr);

float16 __ovld fract(float16 x, __private float16 *iptr);

#ifdef cl_khr_fp64

double __ovld fract(double x, __global double *iptr);

double2 __ovld fract(double2 x, __global double2 *iptr);

double3 __ovld fract(double3 x, __global double3 *iptr);

double4 __ovld fract(double4 x, __global double4 *iptr);

double8 __ovld fract(double8 x, __global double8 *iptr);

double16 __ovld fract(double16 x, __global double16 *iptr);

double __ovld fract(double x, __local double *iptr);

double2 __ovld fract(double2 x, __local double2 *iptr);

double3 __ovld fract(double3 x, __local double3 *iptr);

double4 __ovld fract(double4 x, __local double4 *iptr);

double8 __ovld fract(double8 x, __local double8 *iptr);

double16 __ovld fract(double16 x, __local double16 *iptr);

double __ovld fract(double x, __private double *iptr);

double2 __ovld fract(double2 x, __private double2 *iptr);

double3 __ovld fract(double3 x, __private double3 *iptr);

double4 __ovld fract(double4 x, __private double4 *iptr);

double8 __ovld fract(double8 x, __private double8 *iptr);

double16 __ovld fract(double16 x, __private double16 *iptr);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld fract(half x, __global half *iptr);

half2 __ovld fract(half2 x, __global half2 *iptr);

half3 __ovld fract(half3 x, __global half3 *iptr);

half4 __ovld fract(half4 x, __global half4 *iptr);

half8 __ovld fract(half8 x, __global half8 *iptr);

half16 __ovld fract(half16 x, __global half16 *iptr);

half __ovld fract(half x, __local half *iptr);

half2 __ovld fract(half2 x, __local half2 *iptr);

half3 __ovld fract(half3 x, __local half3 *iptr);

half4 __ovld fract(half4 x, __local half4 *iptr);

half8 __ovld fract(half8 x, __local half8 *iptr);

half16 __ovld fract(half16 x, __local half16 *iptr);

half __ovld fract(half x, __private half *iptr);

half2 __ovld fract(half2 x, __private half2 *iptr);

half3 __ovld fract(half3 x, __private half3 *iptr);

half4 __ovld fract(half4 x, __private half4 *iptr);

half8 __ovld fract(half8 x, __private half8 *iptr);

half16 __ovld fract(half16 x, __private half16 *iptr);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld frexp(float x, int *exp);

float2 __ovld frexp(float2 x, int2 *exp);

float3 __ovld frexp(float3 x, int3 *exp);

float4 __ovld frexp(float4 x, int4 *exp);

float8 __ovld frexp(float8 x, int8 *exp);

float16 __ovld frexp(float16 x, int16 *exp);

#ifdef cl_khr_fp64

double __ovld frexp(double x, int *exp);

double2 __ovld frexp(double2 x, int2 *exp);

double3 __ovld frexp(double3 x, int3 *exp);

double4 __ovld frexp(double4 x, int4 *exp);

double8 __ovld frexp(double8 x, int8 *exp);

double16 __ovld frexp(double16 x, int16 *exp);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld frexp(half x, int *exp);

half2 __ovld frexp(half2 x, int2 *exp);

half3 __ovld frexp(half3 x, int3 *exp);

half4 __ovld frexp(half4 x, int4 *exp);

half8 __ovld frexp(half8 x, int8 *exp);

half16 __ovld frexp(half16 x, int16 *exp);

#endif //cl_khr_fp16

#else

float __ovld frexp(float x, __global int *exp);

float2 __ovld frexp(float2 x, __global int2 *exp);

float3 __ovld frexp(float3 x, __global int3 *exp);

float4 __ovld frexp(float4 x, __global int4 *exp);

float8 __ovld frexp(float8 x, __global int8 *exp);

float16 __ovld frexp(float16 x, __global int16 *exp);

float __ovld frexp(float x, __local int *exp);

float2 __ovld frexp(float2 x, __local int2 *exp);

float3 __ovld frexp(float3 x, __local int3 *exp);

float4 __ovld frexp(float4 x, __local int4 *exp);

float8 __ovld frexp(float8 x, __local int8 *exp);

float16 __ovld frexp(float16 x, __local int16 *exp);

float __ovld frexp(float x, __private int *exp);

float2 __ovld frexp(float2 x, __private int2 *exp);

float3 __ovld frexp(float3 x, __private int3 *exp);

float4 __ovld frexp(float4 x, __private int4 *exp);

float8 __ovld frexp(float8 x, __private int8 *exp);

float16 __ovld frexp(float16 x, __private int16 *exp);

#ifdef cl_khr_fp64

double __ovld frexp(double x, __global int *exp);

double2 __ovld frexp(double2 x, __global int2 *exp);

double3 __ovld frexp(double3 x, __global int3 *exp);

double4 __ovld frexp(double4 x, __global int4 *exp);

double8 __ovld frexp(double8 x, __global int8 *exp);

double16 __ovld frexp(double16 x, __global int16 *exp);

double __ovld frexp(double x, __local int *exp);

double2 __ovld frexp(double2 x, __local int2 *exp);

double3 __ovld frexp(double3 x, __local int3 *exp);

double4 __ovld frexp(double4 x, __local int4 *exp);

double8 __ovld frexp(double8 x, __local int8 *exp);

double16 __ovld frexp(double16 x, __local int16 *exp);

double __ovld frexp(double x, __private int *exp);

double2 __ovld frexp(double2 x, __private int2 *exp);

double3 __ovld frexp(double3 x, __private int3 *exp);

double4 __ovld frexp(double4 x, __private int4 *exp);

double8 __ovld frexp(double8 x, __private int8 *exp);

double16 __ovld frexp(double16 x, __private int16 *exp);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld frexp(half x, __global int *exp);

half2 __ovld frexp(half2 x, __global int2 *exp);

half3 __ovld frexp(half3 x, __global int3 *exp);

half4 __ovld frexp(half4 x, __global int4 *exp);

half8 __ovld frexp(half8 x, __global int8 *exp);

half16 __ovld frexp(half16 x, __global int16 *exp);

half __ovld frexp(half x, __local int *exp);

half2 __ovld frexp(half2 x, __local int2 *exp);

half3 __ovld frexp(half3 x, __local int3 *exp);

half4 __ovld frexp(half4 x, __local int4 *exp);

half8 __ovld frexp(half8 x, __local int8 *exp);

half16 __ovld frexp(half16 x, __local int16 *exp);

half __ovld frexp(half x, __private int *exp);

half2 __ovld frexp(half2 x, __private int2 *exp);

half3 __ovld frexp(half3 x, __private int3 *exp);

half4 __ovld frexp(half4 x, __private int4 *exp);

half8 __ovld frexp(half8 x, __private int8 *exp);

half16 __ovld frexp(half16 x, __private int16 *exp);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float __ovld __cnfn hypot(float x, float y);

float2 __ovld __cnfn hypot(float2 x, float2 y);

float3 __ovld __cnfn hypot(float3 x, float3 y);

float4 __ovld __cnfn hypot(float4 x, float4 y);

float8 __ovld __cnfn hypot(float8 x, float8 y);

float16 __ovld __cnfn hypot(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn hypot(double x, double y);

double2 __ovld __cnfn hypot(double2 x, double2 y);

double3 __ovld __cnfn hypot(double3 x, double3 y);

double4 __ovld __cnfn hypot(double4 x, double4 y);

double8 __ovld __cnfn hypot(double8 x, double8 y);

double16 __ovld __cnfn hypot(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn hypot(half x, half y);

half2 __ovld __cnfn hypot(half2 x, half2 y);

half3 __ovld __cnfn hypot(half3 x, half3 y);

half4 __ovld __cnfn hypot(half4 x, half4 y);

half8 __ovld __cnfn hypot(half8 x, half8 y);

half16 __ovld __cnfn hypot(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn ilogb(float x);

int2 __ovld __cnfn ilogb(float2 x);

int3 __ovld __cnfn ilogb(float3 x);

int4 __ovld __cnfn ilogb(float4 x);

int8 __ovld __cnfn ilogb(float8 x);

int16 __ovld __cnfn ilogb(float16 x);

#ifdef cl_khr_fp64

int __ovld __cnfn ilogb(double x);

int2 __ovld __cnfn ilogb(double2 x);

int3 __ovld __cnfn ilogb(double3 x);

int4 __ovld __cnfn ilogb(double4 x);

int8 __ovld __cnfn ilogb(double8 x);

int16 __ovld __cnfn ilogb(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn ilogb(half x);

int2 __ovld __cnfn ilogb(half2 x);

int3 __ovld __cnfn ilogb(half3 x);

int4 __ovld __cnfn ilogb(half4 x);

int8 __ovld __cnfn ilogb(half8 x);

int16 __ovld __cnfn ilogb(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn ldexp(float x, int n);

float2 __ovld __cnfn ldexp(float2 x, int2 n);

float3 __ovld __cnfn ldexp(float3 x, int3 n);

float4 __ovld __cnfn ldexp(float4 x, int4 n);

float8 __ovld __cnfn ldexp(float8 x, int8 n);

float16 __ovld __cnfn ldexp(float16 x, int16 n);

float2 __ovld __cnfn ldexp(float2 x, int n);

float3 __ovld __cnfn ldexp(float3 x, int n);

float4 __ovld __cnfn ldexp(float4 x, int n);

float8 __ovld __cnfn ldexp(float8 x, int n);

float16 __ovld __cnfn ldexp(float16 x, int n);

#ifdef cl_khr_fp64

double __ovld __cnfn ldexp(double x, int n);

double2 __ovld __cnfn ldexp(double2 x, int2 n);

double3 __ovld __cnfn ldexp(double3 x, int3 n);

double4 __ovld __cnfn ldexp(double4 x, int4 n);

double8 __ovld __cnfn ldexp(double8 x, int8 n);

double16 __ovld __cnfn ldexp(double16 x, int16 n);

double2 __ovld __cnfn ldexp(double2 x, int n);

double3 __ovld __cnfn ldexp(double3 x, int n);

double4 __ovld __cnfn ldexp(double4 x, int n);

double8 __ovld __cnfn ldexp(double8 x, int n);

double16 __ovld __cnfn ldexp(double16 x, int n);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn ldexp(half x, int n);

half2 __ovld __cnfn ldexp(half2 x, int2 n);

half3 __ovld __cnfn ldexp(half3 x, int3 n);

half4 __ovld __cnfn ldexp(half4 x, int4 n);

half8 __ovld __cnfn ldexp(half8 x, int8 n);

half16 __ovld __cnfn ldexp(half16 x, int16 n);

half2 __ovld __cnfn ldexp(half2 x, int n);

half3 __ovld __cnfn ldexp(half3 x, int n);

half4 __ovld __cnfn ldexp(half4 x, int n);

half8 __ovld __cnfn ldexp(half8 x, int n);

half16 __ovld __cnfn ldexp(half16 x, int n);

#endif //cl_khr_fp16


float __ovld __cnfn lgamma(float x);

float2 __ovld __cnfn lgamma(float2 x);

float3 __ovld __cnfn lgamma(float3 x);

float4 __ovld __cnfn lgamma(float4 x);

float8 __ovld __cnfn lgamma(float8 x);

float16 __ovld __cnfn lgamma(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn lgamma(double x);

double2 __ovld __cnfn lgamma(double2 x);

double3 __ovld __cnfn lgamma(double3 x);

double4 __ovld __cnfn lgamma(double4 x);

double8 __ovld __cnfn lgamma(double8 x);

double16 __ovld __cnfn lgamma(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn lgamma(half x);

half2 __ovld __cnfn lgamma(half2 x);

half3 __ovld __cnfn lgamma(half3 x);

half4 __ovld __cnfn lgamma(half4 x);

half8 __ovld __cnfn lgamma(half8 x);

half16 __ovld __cnfn lgamma(half16 x);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld lgamma_r(float x, int *signp);

float2 __ovld lgamma_r(float2 x, int2 *signp);

float3 __ovld lgamma_r(float3 x, int3 *signp);

float4 __ovld lgamma_r(float4 x, int4 *signp);

float8 __ovld lgamma_r(float8 x, int8 *signp);

float16 __ovld lgamma_r(float16 x, int16 *signp);

#ifdef cl_khr_fp64

double __ovld lgamma_r(double x, int *signp);

double2 __ovld lgamma_r(double2 x, int2 *signp);

double3 __ovld lgamma_r(double3 x, int3 *signp);

double4 __ovld lgamma_r(double4 x, int4 *signp);

double8 __ovld lgamma_r(double8 x, int8 *signp);

double16 __ovld lgamma_r(double16 x, int16 *signp);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld lgamma_r(half x, int *signp);

half2 __ovld lgamma_r(half2 x, int2 *signp);

half3 __ovld lgamma_r(half3 x, int3 *signp);

half4 __ovld lgamma_r(half4 x, int4 *signp);

half8 __ovld lgamma_r(half8 x, int8 *signp);

half16 __ovld lgamma_r(half16 x, int16 *signp);

#endif //cl_khr_fp16

#else

float __ovld lgamma_r(float x, __global int *signp);

float2 __ovld lgamma_r(float2 x, __global int2 *signp);

float3 __ovld lgamma_r(float3 x, __global int3 *signp);

float4 __ovld lgamma_r(float4 x, __global int4 *signp);

float8 __ovld lgamma_r(float8 x, __global int8 *signp);

float16 __ovld lgamma_r(float16 x, __global int16 *signp);

float __ovld lgamma_r(float x, __local int *signp);

float2 __ovld lgamma_r(float2 x, __local int2 *signp);

float3 __ovld lgamma_r(float3 x, __local int3 *signp);

float4 __ovld lgamma_r(float4 x, __local int4 *signp);

float8 __ovld lgamma_r(float8 x, __local int8 *signp);

float16 __ovld lgamma_r(float16 x, __local int16 *signp);

float __ovld lgamma_r(float x, __private int *signp);

float2 __ovld lgamma_r(float2 x, __private int2 *signp);

float3 __ovld lgamma_r(float3 x, __private int3 *signp);

float4 __ovld lgamma_r(float4 x, __private int4 *signp);

float8 __ovld lgamma_r(float8 x, __private int8 *signp);

float16 __ovld lgamma_r(float16 x, __private int16 *signp);

#ifdef cl_khr_fp64

double __ovld lgamma_r(double x, __global int *signp);

double2 __ovld lgamma_r(double2 x, __global int2 *signp);

double3 __ovld lgamma_r(double3 x, __global int3 *signp);

double4 __ovld lgamma_r(double4 x, __global int4 *signp);

double8 __ovld lgamma_r(double8 x, __global int8 *signp);

double16 __ovld lgamma_r(double16 x, __global int16 *signp);

double __ovld lgamma_r(double x, __local int *signp);

double2 __ovld lgamma_r(double2 x, __local int2 *signp);

double3 __ovld lgamma_r(double3 x, __local int3 *signp);

double4 __ovld lgamma_r(double4 x, __local int4 *signp);

double8 __ovld lgamma_r(double8 x, __local int8 *signp);

double16 __ovld lgamma_r(double16 x, __local int16 *signp);

double __ovld lgamma_r(double x, __private int *signp);

double2 __ovld lgamma_r(double2 x, __private int2 *signp);

double3 __ovld lgamma_r(double3 x, __private int3 *signp);

double4 __ovld lgamma_r(double4 x, __private int4 *signp);

double8 __ovld lgamma_r(double8 x, __private int8 *signp);

double16 __ovld lgamma_r(double16 x, __private int16 *signp);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld lgamma_r(half x, __global int *signp);

half2 __ovld lgamma_r(half2 x, __global int2 *signp);

half3 __ovld lgamma_r(half3 x, __global int3 *signp);

half4 __ovld lgamma_r(half4 x, __global int4 *signp);

half8 __ovld lgamma_r(half8 x, __global int8 *signp);

half16 __ovld lgamma_r(half16 x, __global int16 *signp);

half __ovld lgamma_r(half x, __local int *signp);

half2 __ovld lgamma_r(half2 x, __local int2 *signp);

half3 __ovld lgamma_r(half3 x, __local int3 *signp);

half4 __ovld lgamma_r(half4 x, __local int4 *signp);

half8 __ovld lgamma_r(half8 x, __local int8 *signp);

half16 __ovld lgamma_r(half16 x, __local int16 *signp);

half __ovld lgamma_r(half x, __private int *signp);

half2 __ovld lgamma_r(half2 x, __private int2 *signp);

half3 __ovld lgamma_r(half3 x, __private int3 *signp);

half4 __ovld lgamma_r(half4 x, __private int4 *signp);

half8 __ovld lgamma_r(half8 x, __private int8 *signp);

half16 __ovld lgamma_r(half16 x, __private int16 *signp);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float __ovld __cnfn log(float);

float2 __ovld __cnfn log(float2);

float3 __ovld __cnfn log(float3);

float4 __ovld __cnfn log(float4);

float8 __ovld __cnfn log(float8);

float16 __ovld __cnfn log(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn log(double);

double2 __ovld __cnfn log(double2);

double3 __ovld __cnfn log(double3);

double4 __ovld __cnfn log(double4);

double8 __ovld __cnfn log(double8);

double16 __ovld __cnfn log(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn log(half);

half2 __ovld __cnfn log(half2);

half3 __ovld __cnfn log(half3);

half4 __ovld __cnfn log(half4);

half8 __ovld __cnfn log(half8);

half16 __ovld __cnfn log(half16);

#endif //cl_khr_fp16


float __ovld __cnfn log2(float);

float2 __ovld __cnfn log2(float2);

float3 __ovld __cnfn log2(float3);

float4 __ovld __cnfn log2(float4);

float8 __ovld __cnfn log2(float8);

float16 __ovld __cnfn log2(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn log2(double);

double2 __ovld __cnfn log2(double2);

double3 __ovld __cnfn log2(double3);

double4 __ovld __cnfn log2(double4);

double8 __ovld __cnfn log2(double8);

double16 __ovld __cnfn log2(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn log2(half);

half2 __ovld __cnfn log2(half2);

half3 __ovld __cnfn log2(half3);

half4 __ovld __cnfn log2(half4);

half8 __ovld __cnfn log2(half8);

half16 __ovld __cnfn log2(half16);

#endif //cl_khr_fp16


float __ovld __cnfn log10(float);

float2 __ovld __cnfn log10(float2);

float3 __ovld __cnfn log10(float3);

float4 __ovld __cnfn log10(float4);

float8 __ovld __cnfn log10(float8);

float16 __ovld __cnfn log10(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn log10(double);

double2 __ovld __cnfn log10(double2);

double3 __ovld __cnfn log10(double3);

double4 __ovld __cnfn log10(double4);

double8 __ovld __cnfn log10(double8);

double16 __ovld __cnfn log10(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn log10(half);

half2 __ovld __cnfn log10(half2);

half3 __ovld __cnfn log10(half3);

half4 __ovld __cnfn log10(half4);

half8 __ovld __cnfn log10(half8);

half16 __ovld __cnfn log10(half16);

#endif //cl_khr_fp16


float __ovld __cnfn log1p(float x);

float2 __ovld __cnfn log1p(float2 x);

float3 __ovld __cnfn log1p(float3 x);

float4 __ovld __cnfn log1p(float4 x);

float8 __ovld __cnfn log1p(float8 x);

float16 __ovld __cnfn log1p(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn log1p(double x);

double2 __ovld __cnfn log1p(double2 x);

double3 __ovld __cnfn log1p(double3 x);

double4 __ovld __cnfn log1p(double4 x);

double8 __ovld __cnfn log1p(double8 x);

double16 __ovld __cnfn log1p(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn log1p(half x);

half2 __ovld __cnfn log1p(half2 x);

half3 __ovld __cnfn log1p(half3 x);

half4 __ovld __cnfn log1p(half4 x);

half8 __ovld __cnfn log1p(half8 x);

half16 __ovld __cnfn log1p(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn logb(float x);

float2 __ovld __cnfn logb(float2 x);

float3 __ovld __cnfn logb(float3 x);

float4 __ovld __cnfn logb(float4 x);

float8 __ovld __cnfn logb(float8 x);

float16 __ovld __cnfn logb(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn logb(double x);

double2 __ovld __cnfn logb(double2 x);

double3 __ovld __cnfn logb(double3 x);

double4 __ovld __cnfn logb(double4 x);

double8 __ovld __cnfn logb(double8 x);

double16 __ovld __cnfn logb(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn logb(half x);

half2 __ovld __cnfn logb(half2 x);

half3 __ovld __cnfn logb(half3 x);

half4 __ovld __cnfn logb(half4 x);

half8 __ovld __cnfn logb(half8 x);

half16 __ovld __cnfn logb(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn mad(float a, float b, float c);

float2 __ovld __cnfn mad(float2 a, float2 b, float2 c);

float3 __ovld __cnfn mad(float3 a, float3 b, float3 c);

float4 __ovld __cnfn mad(float4 a, float4 b, float4 c);

float8 __ovld __cnfn mad(float8 a, float8 b, float8 c);

float16 __ovld __cnfn mad(float16 a, float16 b, float16 c);

#ifdef cl_khr_fp64

double __ovld __cnfn mad(double a, double b, double c);

double2 __ovld __cnfn mad(double2 a, double2 b, double2 c);

double3 __ovld __cnfn mad(double3 a, double3 b, double3 c);

double4 __ovld __cnfn mad(double4 a, double4 b, double4 c);

double8 __ovld __cnfn mad(double8 a, double8 b, double8 c);

double16 __ovld __cnfn mad(double16 a, double16 b, double16 c);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn mad(half a, half b, half c);

half2 __ovld __cnfn mad(half2 a, half2 b, half2 c);

half3 __ovld __cnfn mad(half3 a, half3 b, half3 c);

half4 __ovld __cnfn mad(half4 a, half4 b, half4 c);

half8 __ovld __cnfn mad(half8 a, half8 b, half8 c);

half16 __ovld __cnfn mad(half16 a, half16 b, half16 c);

#endif //cl_khr_fp16


float __ovld __cnfn maxmag(float x, float y);

float2 __ovld __cnfn maxmag(float2 x, float2 y);

float3 __ovld __cnfn maxmag(float3 x, float3 y);

float4 __ovld __cnfn maxmag(float4 x, float4 y);

float8 __ovld __cnfn maxmag(float8 x, float8 y);

float16 __ovld __cnfn maxmag(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn maxmag(double x, double y);

double2 __ovld __cnfn maxmag(double2 x, double2 y);

double3 __ovld __cnfn maxmag(double3 x, double3 y);

double4 __ovld __cnfn maxmag(double4 x, double4 y);

double8 __ovld __cnfn maxmag(double8 x, double8 y);

double16 __ovld __cnfn maxmag(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn maxmag(half x, half y);

half2 __ovld __cnfn maxmag(half2 x, half2 y);

half3 __ovld __cnfn maxmag(half3 x, half3 y);

half4 __ovld __cnfn maxmag(half4 x, half4 y);

half8 __ovld __cnfn maxmag(half8 x, half8 y);

half16 __ovld __cnfn maxmag(half16 x, half16 y);

#endif //cl_khr_fp16


float __ovld __cnfn minmag(float x, float y);

float2 __ovld __cnfn minmag(float2 x, float2 y);

float3 __ovld __cnfn minmag(float3 x, float3 y);

float4 __ovld __cnfn minmag(float4 x, float4 y);

float8 __ovld __cnfn minmag(float8 x, float8 y);

float16 __ovld __cnfn minmag(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn minmag(double x, double y);

double2 __ovld __cnfn minmag(double2 x, double2 y);

double3 __ovld __cnfn minmag(double3 x, double3 y);

double4 __ovld __cnfn minmag(double4 x, double4 y);

double8 __ovld __cnfn minmag(double8 x, double8 y);

double16 __ovld __cnfn minmag(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn minmag(half x, half y);

half2 __ovld __cnfn minmag(half2 x, half2 y);

half3 __ovld __cnfn minmag(half3 x, half3 y);

half4 __ovld __cnfn minmag(half4 x, half4 y);

half8 __ovld __cnfn minmag(half8 x, half8 y);

half16 __ovld __cnfn minmag(half16 x, half16 y);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld modf(float x, float *iptr);

float2 __ovld modf(float2 x, float2 *iptr);

float3 __ovld modf(float3 x, float3 *iptr);

float4 __ovld modf(float4 x, float4 *iptr);

float8 __ovld modf(float8 x, float8 *iptr);

float16 __ovld modf(float16 x, float16 *iptr);

#ifdef cl_khr_fp64

double __ovld modf(double x, double *iptr);

double2 __ovld modf(double2 x, double2 *iptr);

double3 __ovld modf(double3 x, double3 *iptr);

double4 __ovld modf(double4 x, double4 *iptr);

double8 __ovld modf(double8 x, double8 *iptr);

double16 __ovld modf(double16 x, double16 *iptr);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld modf(half x, half *iptr);

half2 __ovld modf(half2 x, half2 *iptr);

half3 __ovld modf(half3 x, half3 *iptr);

half4 __ovld modf(half4 x, half4 *iptr);

half8 __ovld modf(half8 x, half8 *iptr);

half16 __ovld modf(half16 x, half16 *iptr);

#endif //cl_khr_fp16

#else

float __ovld modf(float x, __global float *iptr);

float2 __ovld modf(float2 x, __global float2 *iptr);

float3 __ovld modf(float3 x, __global float3 *iptr);

float4 __ovld modf(float4 x, __global float4 *iptr);

float8 __ovld modf(float8 x, __global float8 *iptr);

float16 __ovld modf(float16 x, __global float16 *iptr);

float __ovld modf(float x, __local float *iptr);

float2 __ovld modf(float2 x, __local float2 *iptr);

float3 __ovld modf(float3 x, __local float3 *iptr);

float4 __ovld modf(float4 x, __local float4 *iptr);

float8 __ovld modf(float8 x, __local float8 *iptr);

float16 __ovld modf(float16 x, __local float16 *iptr);

float __ovld modf(float x, __private float *iptr);

float2 __ovld modf(float2 x, __private float2 *iptr);

float3 __ovld modf(float3 x, __private float3 *iptr);

float4 __ovld modf(float4 x, __private float4 *iptr);

float8 __ovld modf(float8 x, __private float8 *iptr);

float16 __ovld modf(float16 x, __private float16 *iptr);

#ifdef cl_khr_fp64

double __ovld modf(double x, __global double *iptr);

double2 __ovld modf(double2 x, __global double2 *iptr);

double3 __ovld modf(double3 x, __global double3 *iptr);

double4 __ovld modf(double4 x, __global double4 *iptr);

double8 __ovld modf(double8 x, __global double8 *iptr);

double16 __ovld modf(double16 x, __global double16 *iptr);

double __ovld modf(double x, __local double *iptr);

double2 __ovld modf(double2 x, __local double2 *iptr);

double3 __ovld modf(double3 x, __local double3 *iptr);

double4 __ovld modf(double4 x, __local double4 *iptr);

double8 __ovld modf(double8 x, __local double8 *iptr);

double16 __ovld modf(double16 x, __local double16 *iptr);

double __ovld modf(double x, __private double *iptr);

double2 __ovld modf(double2 x, __private double2 *iptr);

double3 __ovld modf(double3 x, __private double3 *iptr);

double4 __ovld modf(double4 x, __private double4 *iptr);

double8 __ovld modf(double8 x, __private double8 *iptr);

double16 __ovld modf(double16 x, __private double16 *iptr);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld modf(half x, __global half *iptr);

half2 __ovld modf(half2 x, __global half2 *iptr);

half3 __ovld modf(half3 x, __global half3 *iptr);

half4 __ovld modf(half4 x, __global half4 *iptr);

half8 __ovld modf(half8 x, __global half8 *iptr);

half16 __ovld modf(half16 x, __global half16 *iptr);

half __ovld modf(half x, __local half *iptr);

half2 __ovld modf(half2 x, __local half2 *iptr);

half3 __ovld modf(half3 x, __local half3 *iptr);

half4 __ovld modf(half4 x, __local half4 *iptr);

half8 __ovld modf(half8 x, __local half8 *iptr);

half16 __ovld modf(half16 x, __local half16 *iptr);

half __ovld modf(half x, __private half *iptr);

half2 __ovld modf(half2 x, __private half2 *iptr);

half3 __ovld modf(half3 x, __private half3 *iptr);

half4 __ovld modf(half4 x, __private half4 *iptr);

half8 __ovld modf(half8 x, __private half8 *iptr);

half16 __ovld modf(half16 x, __private half16 *iptr);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float __ovld __cnfn nan(uint nancode);

float2 __ovld __cnfn nan(uint2 nancode);

float3 __ovld __cnfn nan(uint3 nancode);

float4 __ovld __cnfn nan(uint4 nancode);

float8 __ovld __cnfn nan(uint8 nancode);

float16 __ovld __cnfn nan(uint16 nancode);

#ifdef cl_khr_fp64

double __ovld __cnfn nan(ulong nancode);

double2 __ovld __cnfn nan(ulong2 nancode);

double3 __ovld __cnfn nan(ulong3 nancode);

double4 __ovld __cnfn nan(ulong4 nancode);

double8 __ovld __cnfn nan(ulong8 nancode);

double16 __ovld __cnfn nan(ulong16 nancode);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn nan(ushort nancode);

half2 __ovld __cnfn nan(ushort2 nancode);

half3 __ovld __cnfn nan(ushort3 nancode);

half4 __ovld __cnfn nan(ushort4 nancode);

half8 __ovld __cnfn nan(ushort8 nancode);

half16 __ovld __cnfn nan(ushort16 nancode);

#endif //cl_khr_fp16


float __ovld __cnfn nextafter(float x, float y);

float2 __ovld __cnfn nextafter(float2 x, float2 y);

float3 __ovld __cnfn nextafter(float3 x, float3 y);

float4 __ovld __cnfn nextafter(float4 x, float4 y);

float8 __ovld __cnfn nextafter(float8 x, float8 y);

float16 __ovld __cnfn nextafter(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn nextafter(double x, double y);

double2 __ovld __cnfn nextafter(double2 x, double2 y);

double3 __ovld __cnfn nextafter(double3 x, double3 y);

double4 __ovld __cnfn nextafter(double4 x, double4 y);

double8 __ovld __cnfn nextafter(double8 x, double8 y);

double16 __ovld __cnfn nextafter(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn nextafter(half x, half y);

half2 __ovld __cnfn nextafter(half2 x, half2 y);

half3 __ovld __cnfn nextafter(half3 x, half3 y);

half4 __ovld __cnfn nextafter(half4 x, half4 y);

half8 __ovld __cnfn nextafter(half8 x, half8 y);

half16 __ovld __cnfn nextafter(half16 x, half16 y);

#endif //cl_khr_fp16


float __ovld __cnfn pow(float x, float y);

float2 __ovld __cnfn pow(float2 x, float2 y);

float3 __ovld __cnfn pow(float3 x, float3 y);

float4 __ovld __cnfn pow(float4 x, float4 y);

float8 __ovld __cnfn pow(float8 x, float8 y);

float16 __ovld __cnfn pow(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn pow(double x, double y);

double2 __ovld __cnfn pow(double2 x, double2 y);

double3 __ovld __cnfn pow(double3 x, double3 y);

double4 __ovld __cnfn pow(double4 x, double4 y);

double8 __ovld __cnfn pow(double8 x, double8 y);

double16 __ovld __cnfn pow(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn pow(half x, half y);

half2 __ovld __cnfn pow(half2 x, half2 y);

half3 __ovld __cnfn pow(half3 x, half3 y);

half4 __ovld __cnfn pow(half4 x, half4 y);

half8 __ovld __cnfn pow(half8 x, half8 y);

half16 __ovld __cnfn pow(half16 x, half16 y);

#endif //cl_khr_fp16


float __ovld __cnfn pown(float x, int y);

float2 __ovld __cnfn pown(float2 x, int2 y);

float3 __ovld __cnfn pown(float3 x, int3 y);

float4 __ovld __cnfn pown(float4 x, int4 y);

float8 __ovld __cnfn pown(float8 x, int8 y);

float16 __ovld __cnfn pown(float16 x, int16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn pown(double x, int y);

double2 __ovld __cnfn pown(double2 x, int2 y);

double3 __ovld __cnfn pown(double3 x, int3 y);

double4 __ovld __cnfn pown(double4 x, int4 y);

double8 __ovld __cnfn pown(double8 x, int8 y);

double16 __ovld __cnfn pown(double16 x, int16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn pown(half x, int y);

half2 __ovld __cnfn pown(half2 x, int2 y);

half3 __ovld __cnfn pown(half3 x, int3 y);

half4 __ovld __cnfn pown(half4 x, int4 y);

half8 __ovld __cnfn pown(half8 x, int8 y);

half16 __ovld __cnfn pown(half16 x, int16 y);

#endif //cl_khr_fp16


float __ovld __cnfn powr(float x, float y);

float2 __ovld __cnfn powr(float2 x, float2 y);

float3 __ovld __cnfn powr(float3 x, float3 y);

float4 __ovld __cnfn powr(float4 x, float4 y);

float8 __ovld __cnfn powr(float8 x, float8 y);

float16 __ovld __cnfn powr(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn powr(double x, double y);

double2 __ovld __cnfn powr(double2 x, double2 y);

double3 __ovld __cnfn powr(double3 x, double3 y);

double4 __ovld __cnfn powr(double4 x, double4 y);

double8 __ovld __cnfn powr(double8 x, double8 y);

double16 __ovld __cnfn powr(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn powr(half x, half y);

half2 __ovld __cnfn powr(half2 x, half2 y);

half3 __ovld __cnfn powr(half3 x, half3 y);

half4 __ovld __cnfn powr(half4 x, half4 y);

half8 __ovld __cnfn powr(half8 x, half8 y);

half16 __ovld __cnfn powr(half16 x, half16 y);

#endif //cl_khr_fp16


float __ovld __cnfn remainder(float x, float y);

float2 __ovld __cnfn remainder(float2 x, float2 y);

float3 __ovld __cnfn remainder(float3 x, float3 y);

float4 __ovld __cnfn remainder(float4 x, float4 y);

float8 __ovld __cnfn remainder(float8 x, float8 y);

float16 __ovld __cnfn remainder(float16 x, float16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn remainder(double x, double y);

double2 __ovld __cnfn remainder(double2 x, double2 y);

double3 __ovld __cnfn remainder(double3 x, double3 y);

double4 __ovld __cnfn remainder(double4 x, double4 y);

double8 __ovld __cnfn remainder(double8 x, double8 y);

double16 __ovld __cnfn remainder(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn remainder(half x, half y);

half2 __ovld __cnfn remainder(half2 x, half2 y);

half3 __ovld __cnfn remainder(half3 x, half3 y);

half4 __ovld __cnfn remainder(half4 x, half4 y);

half8 __ovld __cnfn remainder(half8 x, half8 y);

half16 __ovld __cnfn remainder(half16 x, half16 y);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld remquo(float x, float y, int *quo);

float2 __ovld remquo(float2 x, float2 y, int2 *quo);

float3 __ovld remquo(float3 x, float3 y, int3 *quo);

float4 __ovld remquo(float4 x, float4 y, int4 *quo);

float8 __ovld remquo(float8 x, float8 y, int8 *quo);

float16 __ovld remquo(float16 x, float16 y, int16 *quo);

#ifdef cl_khr_fp64

double __ovld remquo(double x, double y, int *quo);

double2 __ovld remquo(double2 x, double2 y, int2 *quo);

double3 __ovld remquo(double3 x, double3 y, int3 *quo);

double4 __ovld remquo(double4 x, double4 y, int4 *quo);

double8 __ovld remquo(double8 x, double8 y, int8 *quo);

double16 __ovld remquo(double16 x, double16 y, int16 *quo);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld remquo(half x, half y, int *quo);

half2 __ovld remquo(half2 x, half2 y, int2 *quo);

half3 __ovld remquo(half3 x, half3 y, int3 *quo);

half4 __ovld remquo(half4 x, half4 y, int4 *quo);

half8 __ovld remquo(half8 x, half8 y, int8 *quo);

half16 __ovld remquo(half16 x, half16 y, int16 *quo);


#endif //cl_khr_fp16

#else

float __ovld remquo(float x, float y, __global int *quo);

float2 __ovld remquo(float2 x, float2 y, __global int2 *quo);

float3 __ovld remquo(float3 x, float3 y, __global int3 *quo);

float4 __ovld remquo(float4 x, float4 y, __global int4 *quo);

float8 __ovld remquo(float8 x, float8 y, __global int8 *quo);

float16 __ovld remquo(float16 x, float16 y, __global int16 *quo);

float __ovld remquo(float x, float y, __local int *quo);

float2 __ovld remquo(float2 x, float2 y, __local int2 *quo);

float3 __ovld remquo(float3 x, float3 y, __local int3 *quo);

float4 __ovld remquo(float4 x, float4 y, __local int4 *quo);

float8 __ovld remquo(float8 x, float8 y, __local int8 *quo);

float16 __ovld remquo(float16 x, float16 y, __local int16 *quo);

float __ovld remquo(float x, float y, __private int *quo);

float2 __ovld remquo(float2 x, float2 y, __private int2 *quo);

float3 __ovld remquo(float3 x, float3 y, __private int3 *quo);

float4 __ovld remquo(float4 x, float4 y, __private int4 *quo);

float8 __ovld remquo(float8 x, float8 y, __private int8 *quo);

float16 __ovld remquo(float16 x, float16 y, __private int16 *quo);

#ifdef cl_khr_fp64

double __ovld remquo(double x, double y, __global int *quo);

double2 __ovld remquo(double2 x, double2 y, __global int2 *quo);

double3 __ovld remquo(double3 x, double3 y, __global int3 *quo);

double4 __ovld remquo(double4 x, double4 y, __global int4 *quo);

double8 __ovld remquo(double8 x, double8 y, __global int8 *quo);

double16 __ovld remquo(double16 x, double16 y, __global int16 *quo);

double __ovld remquo(double x, double y, __local int *quo);

double2 __ovld remquo(double2 x, double2 y, __local int2 *quo);

double3 __ovld remquo(double3 x, double3 y, __local int3 *quo);

double4 __ovld remquo(double4 x, double4 y, __local int4 *quo);

double8 __ovld remquo(double8 x, double8 y, __local int8 *quo);

double16 __ovld remquo(double16 x, double16 y, __local int16 *quo);

double __ovld remquo(double x, double y, __private int *quo);

double2 __ovld remquo(double2 x, double2 y, __private int2 *quo);

double3 __ovld remquo(double3 x, double3 y, __private int3 *quo);

double4 __ovld remquo(double4 x, double4 y, __private int4 *quo);

double8 __ovld remquo(double8 x, double8 y, __private int8 *quo);

double16 __ovld remquo(double16 x, double16 y, __private int16 *quo);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld remquo(half x, half y, __global int *quo);

half2 __ovld remquo(half2 x, half2 y, __global int2 *quo);

half3 __ovld remquo(half3 x, half3 y, __global int3 *quo);

half4 __ovld remquo(half4 x, half4 y, __global int4 *quo);

half8 __ovld remquo(half8 x, half8 y, __global int8 *quo);

half16 __ovld remquo(half16 x, half16 y, __global int16 *quo);

half __ovld remquo(half x, half y, __local int *quo);

half2 __ovld remquo(half2 x, half2 y, __local int2 *quo);

half3 __ovld remquo(half3 x, half3 y, __local int3 *quo);

half4 __ovld remquo(half4 x, half4 y, __local int4 *quo);

half8 __ovld remquo(half8 x, half8 y, __local int8 *quo);

half16 __ovld remquo(half16 x, half16 y, __local int16 *quo);

half __ovld remquo(half x, half y, __private int *quo);

half2 __ovld remquo(half2 x, half2 y, __private int2 *quo);

half3 __ovld remquo(half3 x, half3 y, __private int3 *quo);

half4 __ovld remquo(half4 x, half4 y, __private int4 *quo);

half8 __ovld remquo(half8 x, half8 y, __private int8 *quo);

half16 __ovld remquo(half16 x, half16 y, __private int16 *quo);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld __cnfn rint(float);

float2 __ovld __cnfn rint(float2);

float3 __ovld __cnfn rint(float3);

float4 __ovld __cnfn rint(float4);

float8 __ovld __cnfn rint(float8);

float16 __ovld __cnfn rint(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn rint(double);

double2 __ovld __cnfn rint(double2);

double3 __ovld __cnfn rint(double3);

double4 __ovld __cnfn rint(double4);

double8 __ovld __cnfn rint(double8);

double16 __ovld __cnfn rint(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn rint(half);

half2 __ovld __cnfn rint(half2);

half3 __ovld __cnfn rint(half3);

half4 __ovld __cnfn rint(half4);

half8 __ovld __cnfn rint(half8);

half16 __ovld __cnfn rint(half16);

#endif //cl_khr_fp16


float __ovld __cnfn rootn(float x, int y);

float2 __ovld __cnfn rootn(float2 x, int2 y);

float3 __ovld __cnfn rootn(float3 x, int3 y);

float4 __ovld __cnfn rootn(float4 x, int4 y);

float8 __ovld __cnfn rootn(float8 x, int8 y);

float16 __ovld __cnfn rootn(float16 x, int16 y);

#ifdef cl_khr_fp64

double __ovld __cnfn rootn(double x, int y);

double2 __ovld __cnfn rootn(double2 x, int2 y);

double3 __ovld __cnfn rootn(double3 x, int3 y);

double4 __ovld __cnfn rootn(double4 x, int4 y);

double8 __ovld __cnfn rootn(double8 x, int8 y);

double16 __ovld __cnfn rootn(double16 x, int16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn rootn(half x, int y);

half2 __ovld __cnfn rootn(half2 x, int2 y);

half3 __ovld __cnfn rootn(half3 x, int3 y);

half4 __ovld __cnfn rootn(half4 x, int4 y);

half8 __ovld __cnfn rootn(half8 x, int8 y);

half16 __ovld __cnfn rootn(half16 x, int16 y);

#endif //cl_khr_fp16


float __ovld __cnfn round(float x);

float2 __ovld __cnfn round(float2 x);

float3 __ovld __cnfn round(float3 x);

float4 __ovld __cnfn round(float4 x);

float8 __ovld __cnfn round(float8 x);

float16 __ovld __cnfn round(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn round(double x);

double2 __ovld __cnfn round(double2 x);

double3 __ovld __cnfn round(double3 x);

double4 __ovld __cnfn round(double4 x);

double8 __ovld __cnfn round(double8 x);

double16 __ovld __cnfn round(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn round(half x);

half2 __ovld __cnfn round(half2 x);

half3 __ovld __cnfn round(half3 x);

half4 __ovld __cnfn round(half4 x);

half8 __ovld __cnfn round(half8 x);

half16 __ovld __cnfn round(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn rsqrt(float);

float2 __ovld __cnfn rsqrt(float2);

float3 __ovld __cnfn rsqrt(float3);

float4 __ovld __cnfn rsqrt(float4);

float8 __ovld __cnfn rsqrt(float8);

float16 __ovld __cnfn rsqrt(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn rsqrt(double);

double2 __ovld __cnfn rsqrt(double2);

double3 __ovld __cnfn rsqrt(double3);

double4 __ovld __cnfn rsqrt(double4);

double8 __ovld __cnfn rsqrt(double8);

double16 __ovld __cnfn rsqrt(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn rsqrt(half);

half2 __ovld __cnfn rsqrt(half2);

half3 __ovld __cnfn rsqrt(half3);

half4 __ovld __cnfn rsqrt(half4);

half8 __ovld __cnfn rsqrt(half8);

half16 __ovld __cnfn rsqrt(half16);

#endif //cl_khr_fp16


float __ovld __cnfn sin(float);

float2 __ovld __cnfn sin(float2);

float3 __ovld __cnfn sin(float3);

float4 __ovld __cnfn sin(float4);

float8 __ovld __cnfn sin(float8);

float16 __ovld __cnfn sin(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn sin(double);

double2 __ovld __cnfn sin(double2);

double3 __ovld __cnfn sin(double3);

double4 __ovld __cnfn sin(double4);

double8 __ovld __cnfn sin(double8);

double16 __ovld __cnfn sin(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn sin(half);

half2 __ovld __cnfn sin(half2);

half3 __ovld __cnfn sin(half3);

half4 __ovld __cnfn sin(half4);

half8 __ovld __cnfn sin(half8);

half16 __ovld __cnfn sin(half16);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld sincos(float x, float *cosval);

float2 __ovld sincos(float2 x, float2 *cosval);

float3 __ovld sincos(float3 x, float3 *cosval);

float4 __ovld sincos(float4 x, float4 *cosval);

float8 __ovld sincos(float8 x, float8 *cosval);

float16 __ovld sincos(float16 x, float16 *cosval);

#ifdef cl_khr_fp64

double __ovld sincos(double x, double *cosval);

double2 __ovld sincos(double2 x, double2 *cosval);

double3 __ovld sincos(double3 x, double3 *cosval);

double4 __ovld sincos(double4 x, double4 *cosval);

double8 __ovld sincos(double8 x, double8 *cosval);

double16 __ovld sincos(double16 x, double16 *cosval);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld sincos(half x, half *cosval);

half2 __ovld sincos(half2 x, half2 *cosval);

half3 __ovld sincos(half3 x, half3 *cosval);

half4 __ovld sincos(half4 x, half4 *cosval);

half8 __ovld sincos(half8 x, half8 *cosval);

half16 __ovld sincos(half16 x, half16 *cosval);

#endif //cl_khr_fp16

#else

float __ovld sincos(float x, __global float *cosval);

float2 __ovld sincos(float2 x, __global float2 *cosval);

float3 __ovld sincos(float3 x, __global float3 *cosval);

float4 __ovld sincos(float4 x, __global float4 *cosval);

float8 __ovld sincos(float8 x, __global float8 *cosval);

float16 __ovld sincos(float16 x, __global float16 *cosval);

float __ovld sincos(float x, __local float *cosval);

float2 __ovld sincos(float2 x, __local float2 *cosval);

float3 __ovld sincos(float3 x, __local float3 *cosval);

float4 __ovld sincos(float4 x, __local float4 *cosval);

float8 __ovld sincos(float8 x, __local float8 *cosval);

float16 __ovld sincos(float16 x, __local float16 *cosval);

float __ovld sincos(float x, __private float *cosval);

float2 __ovld sincos(float2 x, __private float2 *cosval);

float3 __ovld sincos(float3 x, __private float3 *cosval);

float4 __ovld sincos(float4 x, __private float4 *cosval);

float8 __ovld sincos(float8 x, __private float8 *cosval);

float16 __ovld sincos(float16 x, __private float16 *cosval);

#ifdef cl_khr_fp64

double __ovld sincos(double x, __global double *cosval);

double2 __ovld sincos(double2 x, __global double2 *cosval);

double3 __ovld sincos(double3 x, __global double3 *cosval);

double4 __ovld sincos(double4 x, __global double4 *cosval);

double8 __ovld sincos(double8 x, __global double8 *cosval);

double16 __ovld sincos(double16 x, __global double16 *cosval);

double __ovld sincos(double x, __local double *cosval);

double2 __ovld sincos(double2 x, __local double2 *cosval);

double3 __ovld sincos(double3 x, __local double3 *cosval);

double4 __ovld sincos(double4 x, __local double4 *cosval);

double8 __ovld sincos(double8 x, __local double8 *cosval);

double16 __ovld sincos(double16 x, __local double16 *cosval);

double __ovld sincos(double x, __private double *cosval);

double2 __ovld sincos(double2 x, __private double2 *cosval);

double3 __ovld sincos(double3 x, __private double3 *cosval);

double4 __ovld sincos(double4 x, __private double4 *cosval);

double8 __ovld sincos(double8 x, __private double8 *cosval);

double16 __ovld sincos(double16 x, __private double16 *cosval);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld sincos(half x, __global half *cosval);

half2 __ovld sincos(half2 x, __global half2 *cosval);

half3 __ovld sincos(half3 x, __global half3 *cosval);

half4 __ovld sincos(half4 x, __global half4 *cosval);

half8 __ovld sincos(half8 x, __global half8 *cosval);

half16 __ovld sincos(half16 x, __global half16 *cosval);

half __ovld sincos(half x, __local half *cosval);

half2 __ovld sincos(half2 x, __local half2 *cosval);

half3 __ovld sincos(half3 x, __local half3 *cosval);

half4 __ovld sincos(half4 x, __local half4 *cosval);

half8 __ovld sincos(half8 x, __local half8 *cosval);

half16 __ovld sincos(half16 x, __local half16 *cosval);

half __ovld sincos(half x, __private half *cosval);

half2 __ovld sincos(half2 x, __private half2 *cosval);

half3 __ovld sincos(half3 x, __private half3 *cosval);

half4 __ovld sincos(half4 x, __private half4 *cosval);

half8 __ovld sincos(half8 x, __private half8 *cosval);

half16 __ovld sincos(half16 x, __private half16 *cosval);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float __ovld __cnfn sinh(float);

float2 __ovld __cnfn sinh(float2);

float3 __ovld __cnfn sinh(float3);

float4 __ovld __cnfn sinh(float4);

float8 __ovld __cnfn sinh(float8);

float16 __ovld __cnfn sinh(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn sinh(double);

double2 __ovld __cnfn sinh(double2);

double3 __ovld __cnfn sinh(double3);

double4 __ovld __cnfn sinh(double4);

double8 __ovld __cnfn sinh(double8);

double16 __ovld __cnfn sinh(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn sinh(half);

half2 __ovld __cnfn sinh(half2);

half3 __ovld __cnfn sinh(half3);

half4 __ovld __cnfn sinh(half4);

half8 __ovld __cnfn sinh(half8);

half16 __ovld __cnfn sinh(half16);

#endif //cl_khr_fp16


float __ovld __cnfn sinpi(float x);

float2 __ovld __cnfn sinpi(float2 x);

float3 __ovld __cnfn sinpi(float3 x);

float4 __ovld __cnfn sinpi(float4 x);

float8 __ovld __cnfn sinpi(float8 x);

float16 __ovld __cnfn sinpi(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn sinpi(double x);

double2 __ovld __cnfn sinpi(double2 x);

double3 __ovld __cnfn sinpi(double3 x);

double4 __ovld __cnfn sinpi(double4 x);

double8 __ovld __cnfn sinpi(double8 x);

double16 __ovld __cnfn sinpi(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn sinpi(half x);

half2 __ovld __cnfn sinpi(half2 x);

half3 __ovld __cnfn sinpi(half3 x);

half4 __ovld __cnfn sinpi(half4 x);

half8 __ovld __cnfn sinpi(half8 x);

half16 __ovld __cnfn sinpi(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn sqrt(float);

float2 __ovld __cnfn sqrt(float2);

float3 __ovld __cnfn sqrt(float3);

float4 __ovld __cnfn sqrt(float4);

float8 __ovld __cnfn sqrt(float8);

float16 __ovld __cnfn sqrt(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn sqrt(double);

double2 __ovld __cnfn sqrt(double2);

double3 __ovld __cnfn sqrt(double3);

double4 __ovld __cnfn sqrt(double4);

double8 __ovld __cnfn sqrt(double8);

double16 __ovld __cnfn sqrt(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn sqrt(half);

half2 __ovld __cnfn sqrt(half2);

half3 __ovld __cnfn sqrt(half3);

half4 __ovld __cnfn sqrt(half4);

half8 __ovld __cnfn sqrt(half8);

half16 __ovld __cnfn sqrt(half16);

#endif //cl_khr_fp16


float __ovld __cnfn tan(float);

float2 __ovld __cnfn tan(float2);

float3 __ovld __cnfn tan(float3);

float4 __ovld __cnfn tan(float4);

float8 __ovld __cnfn tan(float8);

float16 __ovld __cnfn tan(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn tan(double);

double2 __ovld __cnfn tan(double2);

double3 __ovld __cnfn tan(double3);

double4 __ovld __cnfn tan(double4);

double8 __ovld __cnfn tan(double8);

double16 __ovld __cnfn tan(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn tan(half);

half2 __ovld __cnfn tan(half2);

half3 __ovld __cnfn tan(half3);

half4 __ovld __cnfn tan(half4);

half8 __ovld __cnfn tan(half8);

half16 __ovld __cnfn tan(half16);

#endif //cl_khr_fp16


float __ovld __cnfn tanh(float);

float2 __ovld __cnfn tanh(float2);

float3 __ovld __cnfn tanh(float3);

float4 __ovld __cnfn tanh(float4);

float8 __ovld __cnfn tanh(float8);

float16 __ovld __cnfn tanh(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn tanh(double);

double2 __ovld __cnfn tanh(double2);

double3 __ovld __cnfn tanh(double3);

double4 __ovld __cnfn tanh(double4);

double8 __ovld __cnfn tanh(double8);

double16 __ovld __cnfn tanh(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn tanh(half);

half2 __ovld __cnfn tanh(half2);

half3 __ovld __cnfn tanh(half3);

half4 __ovld __cnfn tanh(half4);

half8 __ovld __cnfn tanh(half8);

half16 __ovld __cnfn tanh(half16);

#endif //cl_khr_fp16


float __ovld __cnfn tanpi(float x);

float2 __ovld __cnfn tanpi(float2 x);

float3 __ovld __cnfn tanpi(float3 x);

float4 __ovld __cnfn tanpi(float4 x);

float8 __ovld __cnfn tanpi(float8 x);

float16 __ovld __cnfn tanpi(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn tanpi(double x);

double2 __ovld __cnfn tanpi(double2 x);

double3 __ovld __cnfn tanpi(double3 x);

double4 __ovld __cnfn tanpi(double4 x);

double8 __ovld __cnfn tanpi(double8 x);

double16 __ovld __cnfn tanpi(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn tanpi(half x);

half2 __ovld __cnfn tanpi(half2 x);

half3 __ovld __cnfn tanpi(half3 x);

half4 __ovld __cnfn tanpi(half4 x);

half8 __ovld __cnfn tanpi(half8 x);

half16 __ovld __cnfn tanpi(half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn tgamma(float);

float2 __ovld __cnfn tgamma(float2);

float3 __ovld __cnfn tgamma(float3);

float4 __ovld __cnfn tgamma(float4);

float8 __ovld __cnfn tgamma(float8);

float16 __ovld __cnfn tgamma(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn tgamma(double);

double2 __ovld __cnfn tgamma(double2);

double3 __ovld __cnfn tgamma(double3);

double4 __ovld __cnfn tgamma(double4);

double8 __ovld __cnfn tgamma(double8);

double16 __ovld __cnfn tgamma(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn tgamma(half);

half2 __ovld __cnfn tgamma(half2);

half3 __ovld __cnfn tgamma(half3);

half4 __ovld __cnfn tgamma(half4);

half8 __ovld __cnfn tgamma(half8);

half16 __ovld __cnfn tgamma(half16);

#endif //cl_khr_fp16


float __ovld __cnfn trunc(float);

float2 __ovld __cnfn trunc(float2);

float3 __ovld __cnfn trunc(float3);

float4 __ovld __cnfn trunc(float4);

float8 __ovld __cnfn trunc(float8);

float16 __ovld __cnfn trunc(float16);

#ifdef cl_khr_fp64

double __ovld __cnfn trunc(double);

double2 __ovld __cnfn trunc(double2);

double3 __ovld __cnfn trunc(double3);

double4 __ovld __cnfn trunc(double4);

double8 __ovld __cnfn trunc(double8);

double16 __ovld __cnfn trunc(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn trunc(half);

half2 __ovld __cnfn trunc(half2);

half3 __ovld __cnfn trunc(half3);

half4 __ovld __cnfn trunc(half4);

half8 __ovld __cnfn trunc(half8);

half16 __ovld __cnfn trunc(half16);

#endif //cl_khr_fp16


float __ovld __cnfn half_cos(float x);

float2 __ovld __cnfn half_cos(float2 x);

float3 __ovld __cnfn half_cos(float3 x);

float4 __ovld __cnfn half_cos(float4 x);

float8 __ovld __cnfn half_cos(float8 x);

float16 __ovld __cnfn half_cos(float16 x);


float __ovld __cnfn half_divide(float x, float y);

float2 __ovld __cnfn half_divide(float2 x, float2 y);

float3 __ovld __cnfn half_divide(float3 x, float3 y);

float4 __ovld __cnfn half_divide(float4 x, float4 y);

float8 __ovld __cnfn half_divide(float8 x, float8 y);

float16 __ovld __cnfn half_divide(float16 x, float16 y);


float __ovld __cnfn half_exp(float x);

float2 __ovld __cnfn half_exp(float2 x);

float3 __ovld __cnfn half_exp(float3 x);

float4 __ovld __cnfn half_exp(float4 x);

float8 __ovld __cnfn half_exp(float8 x);

float16 __ovld __cnfn half_exp(float16 x);


float __ovld __cnfn half_exp2(float x);

float2 __ovld __cnfn half_exp2(float2 x);

float3 __ovld __cnfn half_exp2(float3 x);

float4 __ovld __cnfn half_exp2(float4 x);

float8 __ovld __cnfn half_exp2(float8 x);

float16 __ovld __cnfn half_exp2(float16 x);


float __ovld __cnfn half_exp10(float x);

float2 __ovld __cnfn half_exp10(float2 x);

float3 __ovld __cnfn half_exp10(float3 x);

float4 __ovld __cnfn half_exp10(float4 x);

float8 __ovld __cnfn half_exp10(float8 x);

float16 __ovld __cnfn half_exp10(float16 x);


float __ovld __cnfn half_log(float x);

float2 __ovld __cnfn half_log(float2 x);

float3 __ovld __cnfn half_log(float3 x);

float4 __ovld __cnfn half_log(float4 x);

float8 __ovld __cnfn half_log(float8 x);

float16 __ovld __cnfn half_log(float16 x);


float __ovld __cnfn half_log2(float x);

float2 __ovld __cnfn half_log2(float2 x);

float3 __ovld __cnfn half_log2(float3 x);

float4 __ovld __cnfn half_log2(float4 x);

float8 __ovld __cnfn half_log2(float8 x);

float16 __ovld __cnfn half_log2(float16 x);


float __ovld __cnfn half_log10(float x);

float2 __ovld __cnfn half_log10(float2 x);

float3 __ovld __cnfn half_log10(float3 x);

float4 __ovld __cnfn half_log10(float4 x);

float8 __ovld __cnfn half_log10(float8 x);

float16 __ovld __cnfn half_log10(float16 x);


float __ovld __cnfn half_powr(float x, float y);

float2 __ovld __cnfn half_powr(float2 x, float2 y);

float3 __ovld __cnfn half_powr(float3 x, float3 y);

float4 __ovld __cnfn half_powr(float4 x, float4 y);

float8 __ovld __cnfn half_powr(float8 x, float8 y);

float16 __ovld __cnfn half_powr(float16 x, float16 y);


float __ovld __cnfn half_recip(float x);

float2 __ovld __cnfn half_recip(float2 x);

float3 __ovld __cnfn half_recip(float3 x);

float4 __ovld __cnfn half_recip(float4 x);

float8 __ovld __cnfn half_recip(float8 x);

float16 __ovld __cnfn half_recip(float16 x);


float __ovld __cnfn half_rsqrt(float x);

float2 __ovld __cnfn half_rsqrt(float2 x);

float3 __ovld __cnfn half_rsqrt(float3 x);

float4 __ovld __cnfn half_rsqrt(float4 x);

float8 __ovld __cnfn half_rsqrt(float8 x);

float16 __ovld __cnfn half_rsqrt(float16 x);


float __ovld __cnfn half_sin(float x);

float2 __ovld __cnfn half_sin(float2 x);

float3 __ovld __cnfn half_sin(float3 x);

float4 __ovld __cnfn half_sin(float4 x);

float8 __ovld __cnfn half_sin(float8 x);

float16 __ovld __cnfn half_sin(float16 x);


float __ovld __cnfn half_sqrt(float x);

float2 __ovld __cnfn half_sqrt(float2 x);

float3 __ovld __cnfn half_sqrt(float3 x);

float4 __ovld __cnfn half_sqrt(float4 x);

float8 __ovld __cnfn half_sqrt(float8 x);

float16 __ovld __cnfn half_sqrt(float16 x);


float __ovld __cnfn half_tan(float x);

float2 __ovld __cnfn half_tan(float2 x);

float3 __ovld __cnfn half_tan(float3 x);

float4 __ovld __cnfn half_tan(float4 x);

float8 __ovld __cnfn half_tan(float8 x);

float16 __ovld __cnfn half_tan(float16 x);


float __ovld __cnfn native_cos(float x);

float2 __ovld __cnfn native_cos(float2 x);

float3 __ovld __cnfn native_cos(float3 x);

float4 __ovld __cnfn native_cos(float4 x);

float8 __ovld __cnfn native_cos(float8 x);

float16 __ovld __cnfn native_cos(float16 x);


float __ovld __cnfn native_divide(float x, float y);

float2 __ovld __cnfn native_divide(float2 x, float2 y);

float3 __ovld __cnfn native_divide(float3 x, float3 y);

float4 __ovld __cnfn native_divide(float4 x, float4 y);

float8 __ovld __cnfn native_divide(float8 x, float8 y);

float16 __ovld __cnfn native_divide(float16 x, float16 y);


float __ovld __cnfn native_exp(float x);

float2 __ovld __cnfn native_exp(float2 x);

float3 __ovld __cnfn native_exp(float3 x);

float4 __ovld __cnfn native_exp(float4 x);

float8 __ovld __cnfn native_exp(float8 x);

float16 __ovld __cnfn native_exp(float16 x);


float __ovld __cnfn native_exp2(float x);

float2 __ovld __cnfn native_exp2(float2 x);

float3 __ovld __cnfn native_exp2(float3 x);

float4 __ovld __cnfn native_exp2(float4 x);

float8 __ovld __cnfn native_exp2(float8 x);

float16 __ovld __cnfn native_exp2(float16 x);


float __ovld __cnfn native_exp10(float x);

float2 __ovld __cnfn native_exp10(float2 x);

float3 __ovld __cnfn native_exp10(float3 x);

float4 __ovld __cnfn native_exp10(float4 x);

float8 __ovld __cnfn native_exp10(float8 x);

float16 __ovld __cnfn native_exp10(float16 x);


float __ovld __cnfn native_log(float x);

float2 __ovld __cnfn native_log(float2 x);

float3 __ovld __cnfn native_log(float3 x);

float4 __ovld __cnfn native_log(float4 x);

float8 __ovld __cnfn native_log(float8 x);

float16 __ovld __cnfn native_log(float16 x);


float __ovld __cnfn native_log2(float x);

float2 __ovld __cnfn native_log2(float2 x);

float3 __ovld __cnfn native_log2(float3 x);

float4 __ovld __cnfn native_log2(float4 x);

float8 __ovld __cnfn native_log2(float8 x);

float16 __ovld __cnfn native_log2(float16 x);


float __ovld __cnfn native_log10(float x);

float2 __ovld __cnfn native_log10(float2 x);

float3 __ovld __cnfn native_log10(float3 x);

float4 __ovld __cnfn native_log10(float4 x);

float8 __ovld __cnfn native_log10(float8 x);

float16 __ovld __cnfn native_log10(float16 x);


float __ovld __cnfn native_powr(float x, float y);

float2 __ovld __cnfn native_powr(float2 x, float2 y);

float3 __ovld __cnfn native_powr(float3 x, float3 y);

float4 __ovld __cnfn native_powr(float4 x, float4 y);

float8 __ovld __cnfn native_powr(float8 x, float8 y);

float16 __ovld __cnfn native_powr(float16 x, float16 y);


float __ovld __cnfn native_recip(float x);

float2 __ovld __cnfn native_recip(float2 x);

float3 __ovld __cnfn native_recip(float3 x);

float4 __ovld __cnfn native_recip(float4 x);

float8 __ovld __cnfn native_recip(float8 x);

float16 __ovld __cnfn native_recip(float16 x);


float __ovld __cnfn native_rsqrt(float x);

float2 __ovld __cnfn native_rsqrt(float2 x);

float3 __ovld __cnfn native_rsqrt(float3 x);

float4 __ovld __cnfn native_rsqrt(float4 x);

float8 __ovld __cnfn native_rsqrt(float8 x);

float16 __ovld __cnfn native_rsqrt(float16 x);


float __ovld __cnfn native_sin(float x);

float2 __ovld __cnfn native_sin(float2 x);

float3 __ovld __cnfn native_sin(float3 x);

float4 __ovld __cnfn native_sin(float4 x);

float8 __ovld __cnfn native_sin(float8 x);

float16 __ovld __cnfn native_sin(float16 x);


float __ovld __cnfn native_sqrt(float x);

float2 __ovld __cnfn native_sqrt(float2 x);

float3 __ovld __cnfn native_sqrt(float3 x);

float4 __ovld __cnfn native_sqrt(float4 x);

float8 __ovld __cnfn native_sqrt(float8 x);

float16 __ovld __cnfn native_sqrt(float16 x);


float __ovld __cnfn native_tan(float x);

float2 __ovld __cnfn native_tan(float2 x);

float3 __ovld __cnfn native_tan(float3 x);

float4 __ovld __cnfn native_tan(float4 x);

float8 __ovld __cnfn native_tan(float8 x);

float16 __ovld __cnfn native_tan(float16 x);


// OpenCL v1.1 s6.11.3, v1.2 s6.12.3, v2.0 s6.13.3 - Integer Functions


uchar __ovld __cnfn abs(char x);

uchar __ovld __cnfn abs(uchar x);

uchar2 __ovld __cnfn abs(char2 x);

uchar2 __ovld __cnfn abs(uchar2 x);

uchar3 __ovld __cnfn abs(char3 x);

uchar3 __ovld __cnfn abs(uchar3 x);

uchar4 __ovld __cnfn abs(char4 x);

uchar4 __ovld __cnfn abs(uchar4 x);

uchar8 __ovld __cnfn abs(char8 x);

uchar8 __ovld __cnfn abs(uchar8 x);

uchar16 __ovld __cnfn abs(char16 x);

uchar16 __ovld __cnfn abs(uchar16 x);

ushort __ovld __cnfn abs(short x);

ushort __ovld __cnfn abs(ushort x);

ushort2 __ovld __cnfn abs(short2 x);

ushort2 __ovld __cnfn abs(ushort2 x);

ushort3 __ovld __cnfn abs(short3 x);

ushort3 __ovld __cnfn abs(ushort3 x);

ushort4 __ovld __cnfn abs(short4 x);

ushort4 __ovld __cnfn abs(ushort4 x);

ushort8 __ovld __cnfn abs(short8 x);

ushort8 __ovld __cnfn abs(ushort8 x);

ushort16 __ovld __cnfn abs(short16 x);

ushort16 __ovld __cnfn abs(ushort16 x);

uint __ovld __cnfn abs(int x);

uint __ovld __cnfn abs(uint x);

uint2 __ovld __cnfn abs(int2 x);

uint2 __ovld __cnfn abs(uint2 x);

uint3 __ovld __cnfn abs(int3 x);

uint3 __ovld __cnfn abs(uint3 x);

uint4 __ovld __cnfn abs(int4 x);

uint4 __ovld __cnfn abs(uint4 x);

uint8 __ovld __cnfn abs(int8 x);

uint8 __ovld __cnfn abs(uint8 x);

uint16 __ovld __cnfn abs(int16 x);

uint16 __ovld __cnfn abs(uint16 x);

ulong __ovld __cnfn abs(long x);

ulong __ovld __cnfn abs(ulong x);

ulong2 __ovld __cnfn abs(long2 x);

ulong2 __ovld __cnfn abs(ulong2 x);

ulong3 __ovld __cnfn abs(long3 x);

ulong3 __ovld __cnfn abs(ulong3 x);

ulong4 __ovld __cnfn abs(long4 x);

ulong4 __ovld __cnfn abs(ulong4 x);

ulong8 __ovld __cnfn abs(long8 x);

ulong8 __ovld __cnfn abs(ulong8 x);

ulong16 __ovld __cnfn abs(long16 x);

ulong16 __ovld __cnfn abs(ulong16 x);


uchar __ovld __cnfn abs_diff(char x, char y);

uchar __ovld __cnfn abs_diff(uchar x, uchar y);

uchar2 __ovld __cnfn abs_diff(char2 x, char2 y);

uchar2 __ovld __cnfn abs_diff(uchar2 x, uchar2 y);

uchar3 __ovld __cnfn abs_diff(char3 x, char3 y);

uchar3 __ovld __cnfn abs_diff(uchar3 x, uchar3 y);

uchar4 __ovld __cnfn abs_diff(char4 x, char4 y);

uchar4 __ovld __cnfn abs_diff(uchar4 x, uchar4 y);

uchar8 __ovld __cnfn abs_diff(char8 x, char8 y);

uchar8 __ovld __cnfn abs_diff(uchar8 x, uchar8 y);

uchar16 __ovld __cnfn abs_diff(char16 x, char16 y);

uchar16 __ovld __cnfn abs_diff(uchar16 x, uchar16 y);

ushort __ovld __cnfn abs_diff(short x, short y);

ushort __ovld __cnfn abs_diff(ushort x, ushort y);

ushort2 __ovld __cnfn abs_diff(short2 x, short2 y);

ushort2 __ovld __cnfn abs_diff(ushort2 x, ushort2 y);

ushort3 __ovld __cnfn abs_diff(short3 x, short3 y);

ushort3 __ovld __cnfn abs_diff(ushort3 x, ushort3 y);

ushort4 __ovld __cnfn abs_diff(short4 x, short4 y);

ushort4 __ovld __cnfn abs_diff(ushort4 x, ushort4 y);

ushort8 __ovld __cnfn abs_diff(short8 x, short8 y);

ushort8 __ovld __cnfn abs_diff(ushort8 x, ushort8 y);

ushort16 __ovld __cnfn abs_diff(short16 x, short16 y);

ushort16 __ovld __cnfn abs_diff(ushort16 x, ushort16 y);

uint __ovld __cnfn abs_diff(int x, int y);

uint __ovld __cnfn abs_diff(uint x, uint y);

uint2 __ovld __cnfn abs_diff(int2 x, int2 y);

uint2 __ovld __cnfn abs_diff(uint2 x, uint2 y);

uint3 __ovld __cnfn abs_diff(int3 x, int3 y);

uint3 __ovld __cnfn abs_diff(uint3 x, uint3 y);

uint4 __ovld __cnfn abs_diff(int4 x, int4 y);

uint4 __ovld __cnfn abs_diff(uint4 x, uint4 y);

uint8 __ovld __cnfn abs_diff(int8 x, int8 y);

uint8 __ovld __cnfn abs_diff(uint8 x, uint8 y);

uint16 __ovld __cnfn abs_diff(int16 x, int16 y);

uint16 __ovld __cnfn abs_diff(uint16 x, uint16 y);

ulong __ovld __cnfn abs_diff(long x, long y);

ulong __ovld __cnfn abs_diff(ulong x, ulong y);

ulong2 __ovld __cnfn abs_diff(long2 x, long2 y);

ulong2 __ovld __cnfn abs_diff(ulong2 x, ulong2 y);

ulong3 __ovld __cnfn abs_diff(long3 x, long3 y);

ulong3 __ovld __cnfn abs_diff(ulong3 x, ulong3 y);

ulong4 __ovld __cnfn abs_diff(long4 x, long4 y);

ulong4 __ovld __cnfn abs_diff(ulong4 x, ulong4 y);

ulong8 __ovld __cnfn abs_diff(long8 x, long8 y);

ulong8 __ovld __cnfn abs_diff(ulong8 x, ulong8 y);

ulong16 __ovld __cnfn abs_diff(long16 x, long16 y);

ulong16 __ovld __cnfn abs_diff(ulong16 x, ulong16 y);


char __ovld __cnfn add_sat(char x, char y);

uchar __ovld __cnfn add_sat(uchar x, uchar y);

char2 __ovld __cnfn add_sat(char2 x, char2 y);

uchar2 __ovld __cnfn add_sat(uchar2 x, uchar2 y);

char3 __ovld __cnfn add_sat(char3 x, char3 y);

uchar3 __ovld __cnfn add_sat(uchar3 x, uchar3 y);

char4 __ovld __cnfn add_sat(char4 x, char4 y);

uchar4 __ovld __cnfn add_sat(uchar4 x, uchar4 y);

char8 __ovld __cnfn add_sat(char8 x, char8 y);

uchar8 __ovld __cnfn add_sat(uchar8 x, uchar8 y);

char16 __ovld __cnfn add_sat(char16 x, char16 y);

uchar16 __ovld __cnfn add_sat(uchar16 x, uchar16 y);

short __ovld __cnfn add_sat(short x, short y);

ushort __ovld __cnfn add_sat(ushort x, ushort y);

short2 __ovld __cnfn add_sat(short2 x, short2 y);

ushort2 __ovld __cnfn add_sat(ushort2 x, ushort2 y);

short3 __ovld __cnfn add_sat(short3 x, short3 y);

ushort3 __ovld __cnfn add_sat(ushort3 x, ushort3 y);

short4 __ovld __cnfn add_sat(short4 x, short4 y);

ushort4 __ovld __cnfn add_sat(ushort4 x, ushort4 y);

short8 __ovld __cnfn add_sat(short8 x, short8 y);

ushort8 __ovld __cnfn add_sat(ushort8 x, ushort8 y);

short16 __ovld __cnfn add_sat(short16 x, short16 y);

ushort16 __ovld __cnfn add_sat(ushort16 x, ushort16 y);

int __ovld __cnfn add_sat(int x, int y);

uint __ovld __cnfn add_sat(uint x, uint y);

int2 __ovld __cnfn add_sat(int2 x, int2 y);

uint2 __ovld __cnfn add_sat(uint2 x, uint2 y);

int3 __ovld __cnfn add_sat(int3 x, int3 y);

uint3 __ovld __cnfn add_sat(uint3 x, uint3 y);

int4 __ovld __cnfn add_sat(int4 x, int4 y);

uint4 __ovld __cnfn add_sat(uint4 x, uint4 y);

int8 __ovld __cnfn add_sat(int8 x, int8 y);

uint8 __ovld __cnfn add_sat(uint8 x, uint8 y);

int16 __ovld __cnfn add_sat(int16 x, int16 y);

uint16 __ovld __cnfn add_sat(uint16 x, uint16 y);

long __ovld __cnfn add_sat(long x, long y);

ulong __ovld __cnfn add_sat(ulong x, ulong y);

long2 __ovld __cnfn add_sat(long2 x, long2 y);

ulong2 __ovld __cnfn add_sat(ulong2 x, ulong2 y);

long3 __ovld __cnfn add_sat(long3 x, long3 y);

ulong3 __ovld __cnfn add_sat(ulong3 x, ulong3 y);

long4 __ovld __cnfn add_sat(long4 x, long4 y);

ulong4 __ovld __cnfn add_sat(ulong4 x, ulong4 y);

long8 __ovld __cnfn add_sat(long8 x, long8 y);

ulong8 __ovld __cnfn add_sat(ulong8 x, ulong8 y);

long16 __ovld __cnfn add_sat(long16 x, long16 y);

ulong16 __ovld __cnfn add_sat(ulong16 x, ulong16 y);


char __ovld __cnfn hadd(char x, char y);

uchar __ovld __cnfn hadd(uchar x, uchar y);

char2 __ovld __cnfn hadd(char2 x, char2 y);

uchar2 __ovld __cnfn hadd(uchar2 x, uchar2 y);

char3 __ovld __cnfn hadd(char3 x, char3 y);

uchar3 __ovld __cnfn hadd(uchar3 x, uchar3 y);

char4 __ovld __cnfn hadd(char4 x, char4 y);

uchar4 __ovld __cnfn hadd(uchar4 x, uchar4 y);

char8 __ovld __cnfn hadd(char8 x, char8 y);

uchar8 __ovld __cnfn hadd(uchar8 x, uchar8 y);

char16 __ovld __cnfn hadd(char16 x, char16 y);

uchar16 __ovld __cnfn hadd(uchar16 x, uchar16 y);

short __ovld __cnfn hadd(short x, short y);

ushort __ovld __cnfn hadd(ushort x, ushort y);

short2 __ovld __cnfn hadd(short2 x, short2 y);

ushort2 __ovld __cnfn hadd(ushort2 x, ushort2 y);

short3 __ovld __cnfn hadd(short3 x, short3 y);

ushort3 __ovld __cnfn hadd(ushort3 x, ushort3 y);

short4 __ovld __cnfn hadd(short4 x, short4 y);

ushort4 __ovld __cnfn hadd(ushort4 x, ushort4 y);

short8 __ovld __cnfn hadd(short8 x, short8 y);

ushort8 __ovld __cnfn hadd(ushort8 x, ushort8 y);

short16 __ovld __cnfn hadd(short16 x, short16 y);

ushort16 __ovld __cnfn hadd(ushort16 x, ushort16 y);

int __ovld __cnfn hadd(int x, int y);

uint __ovld __cnfn hadd(uint x, uint y);

int2 __ovld __cnfn hadd(int2 x, int2 y);

uint2 __ovld __cnfn hadd(uint2 x, uint2 y);

int3 __ovld __cnfn hadd(int3 x, int3 y);

uint3 __ovld __cnfn hadd(uint3 x, uint3 y);

int4 __ovld __cnfn hadd(int4 x, int4 y);

uint4 __ovld __cnfn hadd(uint4 x, uint4 y);

int8 __ovld __cnfn hadd(int8 x, int8 y);

uint8 __ovld __cnfn hadd(uint8 x, uint8 y);

int16 __ovld __cnfn hadd(int16 x, int16 y);

uint16 __ovld __cnfn hadd(uint16 x, uint16 y);

long __ovld __cnfn hadd(long x, long y);

ulong __ovld __cnfn hadd(ulong x, ulong y);

long2 __ovld __cnfn hadd(long2 x, long2 y);

ulong2 __ovld __cnfn hadd(ulong2 x, ulong2 y);

long3 __ovld __cnfn hadd(long3 x, long3 y);

ulong3 __ovld __cnfn hadd(ulong3 x, ulong3 y);

long4 __ovld __cnfn hadd(long4 x, long4 y);

ulong4 __ovld __cnfn hadd(ulong4 x, ulong4 y);

long8 __ovld __cnfn hadd(long8 x, long8 y);

ulong8 __ovld __cnfn hadd(ulong8 x, ulong8 y);

long16 __ovld __cnfn hadd(long16 x, long16 y);

ulong16 __ovld __cnfn hadd(ulong16 x, ulong16 y);


char __ovld __cnfn rhadd(char x, char y);

uchar __ovld __cnfn rhadd(uchar x, uchar y);

char2 __ovld __cnfn rhadd(char2 x, char2 y);

uchar2 __ovld __cnfn rhadd(uchar2 x, uchar2 y);

char3 __ovld __cnfn rhadd(char3 x, char3 y);

uchar3 __ovld __cnfn rhadd(uchar3 x, uchar3 y);

char4 __ovld __cnfn rhadd(char4 x, char4 y);

uchar4 __ovld __cnfn rhadd(uchar4 x, uchar4 y);

char8 __ovld __cnfn rhadd(char8 x, char8 y);

uchar8 __ovld __cnfn rhadd(uchar8 x, uchar8 y);

char16 __ovld __cnfn rhadd(char16 x, char16 y);

uchar16 __ovld __cnfn rhadd(uchar16 x, uchar16 y);

short __ovld __cnfn rhadd(short x, short y);

ushort __ovld __cnfn rhadd(ushort x, ushort y);

short2 __ovld __cnfn rhadd(short2 x, short2 y);

ushort2 __ovld __cnfn rhadd(ushort2 x, ushort2 y);

short3 __ovld __cnfn rhadd(short3 x, short3 y);

ushort3 __ovld __cnfn rhadd(ushort3 x, ushort3 y);

short4 __ovld __cnfn rhadd(short4 x, short4 y);

ushort4 __ovld __cnfn rhadd(ushort4 x, ushort4 y);

short8 __ovld __cnfn rhadd(short8 x, short8 y);

ushort8 __ovld __cnfn rhadd(ushort8 x, ushort8 y);

short16 __ovld __cnfn rhadd(short16 x, short16 y);

ushort16 __ovld __cnfn rhadd(ushort16 x, ushort16 y);

int __ovld __cnfn rhadd(int x, int y);

uint __ovld __cnfn rhadd(uint x, uint y);

int2 __ovld __cnfn rhadd(int2 x, int2 y);

uint2 __ovld __cnfn rhadd(uint2 x, uint2 y);

int3 __ovld __cnfn rhadd(int3 x, int3 y);

uint3 __ovld __cnfn rhadd(uint3 x, uint3 y);

int4 __ovld __cnfn rhadd(int4 x, int4 y);

uint4 __ovld __cnfn rhadd(uint4 x, uint4 y);

int8 __ovld __cnfn rhadd(int8 x, int8 y);

uint8 __ovld __cnfn rhadd(uint8 x, uint8 y);

int16 __ovld __cnfn rhadd(int16 x, int16 y);

uint16 __ovld __cnfn rhadd(uint16 x, uint16 y);

long __ovld __cnfn rhadd(long x, long y);

ulong __ovld __cnfn rhadd(ulong x, ulong y);

long2 __ovld __cnfn rhadd(long2 x, long2 y);

ulong2 __ovld __cnfn rhadd(ulong2 x, ulong2 y);

long3 __ovld __cnfn rhadd(long3 x, long3 y);

ulong3 __ovld __cnfn rhadd(ulong3 x, ulong3 y);

long4 __ovld __cnfn rhadd(long4 x, long4 y);

ulong4 __ovld __cnfn rhadd(ulong4 x, ulong4 y);

long8 __ovld __cnfn rhadd(long8 x, long8 y);

ulong8 __ovld __cnfn rhadd(ulong8 x, ulong8 y);

long16 __ovld __cnfn rhadd(long16 x, long16 y);

ulong16 __ovld __cnfn rhadd(ulong16 x, ulong16 y);


char __ovld __cnfn clamp(char x, char minval, char maxval);

uchar __ovld __cnfn clamp(uchar x, uchar minval, uchar maxval);

char2 __ovld __cnfn clamp(char2 x, char2 minval, char2 maxval);

uchar2 __ovld __cnfn clamp(uchar2 x, uchar2 minval, uchar2 maxval);

char3 __ovld __cnfn clamp(char3 x, char3 minval, char3 maxval);

uchar3 __ovld __cnfn clamp(uchar3 x, uchar3 minval, uchar3 maxval);

char4 __ovld __cnfn clamp(char4 x, char4 minval, char4 maxval);

uchar4 __ovld __cnfn clamp(uchar4 x, uchar4 minval, uchar4 maxval);

char8 __ovld __cnfn clamp(char8 x, char8 minval, char8 maxval);

uchar8 __ovld __cnfn clamp(uchar8 x, uchar8 minval, uchar8 maxval);

char16 __ovld __cnfn clamp(char16 x, char16 minval, char16 maxval);

uchar16 __ovld __cnfn clamp(uchar16 x, uchar16 minval, uchar16 maxval);

short __ovld __cnfn clamp(short x, short minval, short maxval);

ushort __ovld __cnfn clamp(ushort x, ushort minval, ushort maxval);

short2 __ovld __cnfn clamp(short2 x, short2 minval, short2 maxval);

ushort2 __ovld __cnfn clamp(ushort2 x, ushort2 minval, ushort2 maxval);

short3 __ovld __cnfn clamp(short3 x, short3 minval, short3 maxval);

ushort3 __ovld __cnfn clamp(ushort3 x, ushort3 minval, ushort3 maxval);

short4 __ovld __cnfn clamp(short4 x, short4 minval, short4 maxval);

ushort4 __ovld __cnfn clamp(ushort4 x, ushort4 minval, ushort4 maxval);

short8 __ovld __cnfn clamp(short8 x, short8 minval, short8 maxval);

ushort8 __ovld __cnfn clamp(ushort8 x, ushort8 minval, ushort8 maxval);

short16 __ovld __cnfn clamp(short16 x, short16 minval, short16 maxval);

ushort16 __ovld __cnfn clamp(ushort16 x, ushort16 minval, ushort16 maxval);

int __ovld __cnfn clamp(int x, int minval, int maxval);

uint __ovld __cnfn clamp(uint x, uint minval, uint maxval);

int2 __ovld __cnfn clamp(int2 x, int2 minval, int2 maxval);

uint2 __ovld __cnfn clamp(uint2 x, uint2 minval, uint2 maxval);

int3 __ovld __cnfn clamp(int3 x, int3 minval, int3 maxval);

uint3 __ovld __cnfn clamp(uint3 x, uint3 minval, uint3 maxval);

int4 __ovld __cnfn clamp(int4 x, int4 minval, int4 maxval);

uint4 __ovld __cnfn clamp(uint4 x, uint4 minval, uint4 maxval);

int8 __ovld __cnfn clamp(int8 x, int8 minval, int8 maxval);

uint8 __ovld __cnfn clamp(uint8 x, uint8 minval, uint8 maxval);

int16 __ovld __cnfn clamp(int16 x, int16 minval, int16 maxval);

uint16 __ovld __cnfn clamp(uint16 x, uint16 minval, uint16 maxval);

long __ovld __cnfn clamp(long x, long minval, long maxval);

ulong __ovld __cnfn clamp(ulong x, ulong minval, ulong maxval);

long2 __ovld __cnfn clamp(long2 x, long2 minval, long2 maxval);

ulong2 __ovld __cnfn clamp(ulong2 x, ulong2 minval, ulong2 maxval);

long3 __ovld __cnfn clamp(long3 x, long3 minval, long3 maxval);

ulong3 __ovld __cnfn clamp(ulong3 x, ulong3 minval, ulong3 maxval);

long4 __ovld __cnfn clamp(long4 x, long4 minval, long4 maxval);

ulong4 __ovld __cnfn clamp(ulong4 x, ulong4 minval, ulong4 maxval);

long8 __ovld __cnfn clamp(long8 x, long8 minval, long8 maxval);

ulong8 __ovld __cnfn clamp(ulong8 x, ulong8 minval, ulong8 maxval);

long16 __ovld __cnfn clamp(long16 x, long16 minval, long16 maxval);

ulong16 __ovld __cnfn clamp(ulong16 x, ulong16 minval, ulong16 maxval);

char2 __ovld __cnfn clamp(char2 x, char minval, char maxval);

uchar2 __ovld __cnfn clamp(uchar2 x, uchar minval, uchar maxval);

char3 __ovld __cnfn clamp(char3 x, char minval, char maxval);

uchar3 __ovld __cnfn clamp(uchar3 x, uchar minval, uchar maxval);

char4 __ovld __cnfn clamp(char4 x, char minval, char maxval);

uchar4 __ovld __cnfn clamp(uchar4 x, uchar minval, uchar maxval);

char8 __ovld __cnfn clamp(char8 x, char minval, char maxval);

uchar8 __ovld __cnfn clamp(uchar8 x, uchar minval, uchar maxval);

char16 __ovld __cnfn clamp(char16 x, char minval, char maxval);

uchar16 __ovld __cnfn clamp(uchar16 x, uchar minval, uchar maxval);

short2 __ovld __cnfn clamp(short2 x, short minval, short maxval);

ushort2 __ovld __cnfn clamp(ushort2 x, ushort minval, ushort maxval);

short3 __ovld __cnfn clamp(short3 x, short minval, short maxval);

ushort3 __ovld __cnfn clamp(ushort3 x, ushort minval, ushort maxval);

short4 __ovld __cnfn clamp(short4 x, short minval, short maxval);

ushort4 __ovld __cnfn clamp(ushort4 x, ushort minval, ushort maxval);

short8 __ovld __cnfn clamp(short8 x, short minval, short maxval);

ushort8 __ovld __cnfn clamp(ushort8 x, ushort minval, ushort maxval);

short16 __ovld __cnfn clamp(short16 x, short minval, short maxval);

ushort16 __ovld __cnfn clamp(ushort16 x, ushort minval, ushort maxval);

int2 __ovld __cnfn clamp(int2 x, int minval, int maxval);

uint2 __ovld __cnfn clamp(uint2 x, uint minval, uint maxval);

int3 __ovld __cnfn clamp(int3 x, int minval, int maxval);

uint3 __ovld __cnfn clamp(uint3 x, uint minval, uint maxval);

int4 __ovld __cnfn clamp(int4 x, int minval, int maxval);

uint4 __ovld __cnfn clamp(uint4 x, uint minval, uint maxval);

int8 __ovld __cnfn clamp(int8 x, int minval, int maxval);

uint8 __ovld __cnfn clamp(uint8 x, uint minval, uint maxval);

int16 __ovld __cnfn clamp(int16 x, int minval, int maxval);

uint16 __ovld __cnfn clamp(uint16 x, uint minval, uint maxval);

long2 __ovld __cnfn clamp(long2 x, long minval, long maxval);

ulong2 __ovld __cnfn clamp(ulong2 x, ulong minval, ulong maxval);

long3 __ovld __cnfn clamp(long3 x, long minval, long maxval);

ulong3 __ovld __cnfn clamp(ulong3 x, ulong minval, ulong maxval);

long4 __ovld __cnfn clamp(long4 x, long minval, long maxval);

ulong4 __ovld __cnfn clamp(ulong4 x, ulong minval, ulong maxval);

long8 __ovld __cnfn clamp(long8 x, long minval, long maxval);

ulong8 __ovld __cnfn clamp(ulong8 x, ulong minval, ulong maxval);

long16 __ovld __cnfn clamp(long16 x, long minval, long maxval);

ulong16 __ovld __cnfn clamp(ulong16 x, ulong minval, ulong maxval);


char __ovld __cnfn clz(char x);

uchar __ovld __cnfn clz(uchar x);

char2 __ovld __cnfn clz(char2 x);

uchar2 __ovld __cnfn clz(uchar2 x);

char3 __ovld __cnfn clz(char3 x);

uchar3 __ovld __cnfn clz(uchar3 x);

char4 __ovld __cnfn clz(char4 x);

uchar4 __ovld __cnfn clz(uchar4 x);

char8 __ovld __cnfn clz(char8 x);

uchar8 __ovld __cnfn clz(uchar8 x);

char16 __ovld __cnfn clz(char16 x);

uchar16 __ovld __cnfn clz(uchar16 x);

short __ovld __cnfn clz(short x);

ushort __ovld __cnfn clz(ushort x);

short2 __ovld __cnfn clz(short2 x);

ushort2 __ovld __cnfn clz(ushort2 x);

short3 __ovld __cnfn clz(short3 x);

ushort3 __ovld __cnfn clz(ushort3 x);

short4 __ovld __cnfn clz(short4 x);

ushort4 __ovld __cnfn clz(ushort4 x);

short8 __ovld __cnfn clz(short8 x);

ushort8 __ovld __cnfn clz(ushort8 x);

short16 __ovld __cnfn clz(short16 x);

ushort16 __ovld __cnfn clz(ushort16 x);

int __ovld __cnfn clz(int x);

uint __ovld __cnfn clz(uint x);

int2 __ovld __cnfn clz(int2 x);

uint2 __ovld __cnfn clz(uint2 x);

int3 __ovld __cnfn clz(int3 x);

uint3 __ovld __cnfn clz(uint3 x);

int4 __ovld __cnfn clz(int4 x);

uint4 __ovld __cnfn clz(uint4 x);

int8 __ovld __cnfn clz(int8 x);

uint8 __ovld __cnfn clz(uint8 x);

int16 __ovld __cnfn clz(int16 x);

uint16 __ovld __cnfn clz(uint16 x);

long __ovld __cnfn clz(long x);

ulong __ovld __cnfn clz(ulong x);

long2 __ovld __cnfn clz(long2 x);

ulong2 __ovld __cnfn clz(ulong2 x);

long3 __ovld __cnfn clz(long3 x);

ulong3 __ovld __cnfn clz(ulong3 x);

long4 __ovld __cnfn clz(long4 x);

ulong4 __ovld __cnfn clz(ulong4 x);

long8 __ovld __cnfn clz(long8 x);

ulong8 __ovld __cnfn clz(ulong8 x);

long16 __ovld __cnfn clz(long16 x);

ulong16 __ovld __cnfn clz(ulong16 x);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

char __ovld ctz(char x);

uchar __ovld ctz(uchar x);

char2 __ovld ctz(char2 x);

uchar2 __ovld ctz(uchar2 x);

char3 __ovld ctz(char3 x);

uchar3 __ovld ctz(uchar3 x);

char4 __ovld ctz(char4 x);

uchar4 __ovld ctz(uchar4 x);

char8 __ovld ctz(char8 x);

uchar8 __ovld ctz(uchar8 x);

char16 __ovld ctz(char16 x);

uchar16 __ovld ctz(uchar16 x);

short __ovld ctz(short x);

ushort __ovld ctz(ushort x);

short2 __ovld ctz(short2 x);

ushort2 __ovld ctz(ushort2 x);

short3 __ovld ctz(short3 x);

ushort3 __ovld ctz(ushort3 x);

short4 __ovld ctz(short4 x);

ushort4 __ovld ctz(ushort4 x);

short8 __ovld ctz(short8 x);

ushort8 __ovld ctz(ushort8 x);

short16 __ovld ctz(short16 x);

ushort16 __ovld ctz(ushort16 x);

int __ovld ctz(int x);

uint __ovld ctz(uint x);

int2 __ovld ctz(int2 x);

uint2 __ovld ctz(uint2 x);

int3 __ovld ctz(int3 x);

uint3 __ovld ctz(uint3 x);

int4 __ovld ctz(int4 x);

uint4 __ovld ctz(uint4 x);

int8 __ovld ctz(int8 x);

uint8 __ovld ctz(uint8 x);

int16 __ovld ctz(int16 x);

uint16 __ovld ctz(uint16 x);

long __ovld ctz(long x);

ulong __ovld ctz(ulong x);

long2 __ovld ctz(long2 x);

ulong2 __ovld ctz(ulong2 x);

long3 __ovld ctz(long3 x);

ulong3 __ovld ctz(ulong3 x);

long4 __ovld ctz(long4 x);

ulong4 __ovld ctz(ulong4 x);

long8 __ovld ctz(long8 x);

ulong8 __ovld ctz(ulong8 x);

long16 __ovld ctz(long16 x);

ulong16 __ovld ctz(ulong16 x);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


char __ovld __cnfn mad_hi(char a, char b, char c);

uchar __ovld __cnfn mad_hi(uchar a, uchar b, uchar c);

char2 __ovld __cnfn mad_hi(char2 a, char2 b, char2 c);

uchar2 __ovld __cnfn mad_hi(uchar2 a, uchar2 b, uchar2 c);

char3 __ovld __cnfn mad_hi(char3 a, char3 b, char3 c);

uchar3 __ovld __cnfn mad_hi(uchar3 a, uchar3 b, uchar3 c);

char4 __ovld __cnfn mad_hi(char4 a, char4 b, char4 c);

uchar4 __ovld __cnfn mad_hi(uchar4 a, uchar4 b, uchar4 c);

char8 __ovld __cnfn mad_hi(char8 a, char8 b, char8 c);

uchar8 __ovld __cnfn mad_hi(uchar8 a, uchar8 b, uchar8 c);

char16 __ovld __cnfn mad_hi(char16 a, char16 b, char16 c);

uchar16 __ovld __cnfn mad_hi(uchar16 a, uchar16 b, uchar16 c);

short __ovld __cnfn mad_hi(short a, short b, short c);

ushort __ovld __cnfn mad_hi(ushort a, ushort b, ushort c);

short2 __ovld __cnfn mad_hi(short2 a, short2 b, short2 c);

ushort2 __ovld __cnfn mad_hi(ushort2 a, ushort2 b, ushort2 c);

short3 __ovld __cnfn mad_hi(short3 a, short3 b, short3 c);

ushort3 __ovld __cnfn mad_hi(ushort3 a, ushort3 b, ushort3 c);

short4 __ovld __cnfn mad_hi(short4 a, short4 b, short4 c);

ushort4 __ovld __cnfn mad_hi(ushort4 a, ushort4 b, ushort4 c);

short8 __ovld __cnfn mad_hi(short8 a, short8 b, short8 c);

ushort8 __ovld __cnfn mad_hi(ushort8 a, ushort8 b, ushort8 c);

short16 __ovld __cnfn mad_hi(short16 a, short16 b, short16 c);

ushort16 __ovld __cnfn mad_hi(ushort16 a, ushort16 b, ushort16 c);

int __ovld __cnfn mad_hi(int a, int b, int c);

uint __ovld __cnfn mad_hi(uint a, uint b, uint c);

int2 __ovld __cnfn mad_hi(int2 a, int2 b, int2 c);

uint2 __ovld __cnfn mad_hi(uint2 a, uint2 b, uint2 c);

int3 __ovld __cnfn mad_hi(int3 a, int3 b, int3 c);

uint3 __ovld __cnfn mad_hi(uint3 a, uint3 b, uint3 c);

int4 __ovld __cnfn mad_hi(int4 a, int4 b, int4 c);

uint4 __ovld __cnfn mad_hi(uint4 a, uint4 b, uint4 c);

int8 __ovld __cnfn mad_hi(int8 a, int8 b, int8 c);

uint8 __ovld __cnfn mad_hi(uint8 a, uint8 b, uint8 c);

int16 __ovld __cnfn mad_hi(int16 a, int16 b, int16 c);

uint16 __ovld __cnfn mad_hi(uint16 a, uint16 b, uint16 c);

long __ovld __cnfn mad_hi(long a, long b, long c);

ulong __ovld __cnfn mad_hi(ulong a, ulong b, ulong c);

long2 __ovld __cnfn mad_hi(long2 a, long2 b, long2 c);

ulong2 __ovld __cnfn mad_hi(ulong2 a, ulong2 b, ulong2 c);

long3 __ovld __cnfn mad_hi(long3 a, long3 b, long3 c);

ulong3 __ovld __cnfn mad_hi(ulong3 a, ulong3 b, ulong3 c);

long4 __ovld __cnfn mad_hi(long4 a, long4 b, long4 c);

ulong4 __ovld __cnfn mad_hi(ulong4 a, ulong4 b, ulong4 c);

long8 __ovld __cnfn mad_hi(long8 a, long8 b, long8 c);

ulong8 __ovld __cnfn mad_hi(ulong8 a, ulong8 b, ulong8 c);

long16 __ovld __cnfn mad_hi(long16 a, long16 b, long16 c);

ulong16 __ovld __cnfn mad_hi(ulong16 a, ulong16 b, ulong16 c);


char __ovld __cnfn mad_sat(char a, char b, char c);

uchar __ovld __cnfn mad_sat(uchar a, uchar b, uchar c);

char2 __ovld __cnfn mad_sat(char2 a, char2 b, char2 c);

uchar2 __ovld __cnfn mad_sat(uchar2 a, uchar2 b, uchar2 c);

char3 __ovld __cnfn mad_sat(char3 a, char3 b, char3 c);

uchar3 __ovld __cnfn mad_sat(uchar3 a, uchar3 b, uchar3 c);

char4 __ovld __cnfn mad_sat(char4 a, char4 b, char4 c);

uchar4 __ovld __cnfn mad_sat(uchar4 a, uchar4 b, uchar4 c);

char8 __ovld __cnfn mad_sat(char8 a, char8 b, char8 c);

uchar8 __ovld __cnfn mad_sat(uchar8 a, uchar8 b, uchar8 c);

char16 __ovld __cnfn mad_sat(char16 a, char16 b, char16 c);

uchar16 __ovld __cnfn mad_sat(uchar16 a, uchar16 b, uchar16 c);

short __ovld __cnfn mad_sat(short a, short b, short c);

ushort __ovld __cnfn mad_sat(ushort a, ushort b, ushort c);

short2 __ovld __cnfn mad_sat(short2 a, short2 b, short2 c);

ushort2 __ovld __cnfn mad_sat(ushort2 a, ushort2 b, ushort2 c);

short3 __ovld __cnfn mad_sat(short3 a, short3 b, short3 c);

ushort3 __ovld __cnfn mad_sat(ushort3 a, ushort3 b, ushort3 c);

short4 __ovld __cnfn mad_sat(short4 a, short4 b, short4 c);

ushort4 __ovld __cnfn mad_sat(ushort4 a, ushort4 b, ushort4 c);

short8 __ovld __cnfn mad_sat(short8 a, short8 b, short8 c);

ushort8 __ovld __cnfn mad_sat(ushort8 a, ushort8 b, ushort8 c);

short16 __ovld __cnfn mad_sat(short16 a, short16 b, short16 c);

ushort16 __ovld __cnfn mad_sat(ushort16 a, ushort16 b, ushort16 c);

int __ovld __cnfn mad_sat(int a, int b, int c);

uint __ovld __cnfn mad_sat(uint a, uint b, uint c);

int2 __ovld __cnfn mad_sat(int2 a, int2 b, int2 c);

uint2 __ovld __cnfn mad_sat(uint2 a, uint2 b, uint2 c);

int3 __ovld __cnfn mad_sat(int3 a, int3 b, int3 c);

uint3 __ovld __cnfn mad_sat(uint3 a, uint3 b, uint3 c);

int4 __ovld __cnfn mad_sat(int4 a, int4 b, int4 c);

uint4 __ovld __cnfn mad_sat(uint4 a, uint4 b, uint4 c);

int8 __ovld __cnfn mad_sat(int8 a, int8 b, int8 c);

uint8 __ovld __cnfn mad_sat(uint8 a, uint8 b, uint8 c);

int16 __ovld __cnfn mad_sat(int16 a, int16 b, int16 c);

uint16 __ovld __cnfn mad_sat(uint16 a, uint16 b, uint16 c);

long __ovld __cnfn mad_sat(long a, long b, long c);

ulong __ovld __cnfn mad_sat(ulong a, ulong b, ulong c);

long2 __ovld __cnfn mad_sat(long2 a, long2 b, long2 c);

ulong2 __ovld __cnfn mad_sat(ulong2 a, ulong2 b, ulong2 c);

long3 __ovld __cnfn mad_sat(long3 a, long3 b, long3 c);

ulong3 __ovld __cnfn mad_sat(ulong3 a, ulong3 b, ulong3 c);

long4 __ovld __cnfn mad_sat(long4 a, long4 b, long4 c);

ulong4 __ovld __cnfn mad_sat(ulong4 a, ulong4 b, ulong4 c);

long8 __ovld __cnfn mad_sat(long8 a, long8 b, long8 c);

ulong8 __ovld __cnfn mad_sat(ulong8 a, ulong8 b, ulong8 c);

long16 __ovld __cnfn mad_sat(long16 a, long16 b, long16 c);

ulong16 __ovld __cnfn mad_sat(ulong16 a, ulong16 b, ulong16 c);


char __ovld __cnfn max(char x, char y);

uchar __ovld __cnfn max(uchar x, uchar y);

char2 __ovld __cnfn max(char2 x, char2 y);

uchar2 __ovld __cnfn max(uchar2 x, uchar2 y);

char3 __ovld __cnfn max(char3 x, char3 y);

uchar3 __ovld __cnfn max(uchar3 x, uchar3 y);

char4 __ovld __cnfn max(char4 x, char4 y);

uchar4 __ovld __cnfn max(uchar4 x, uchar4 y);

char8 __ovld __cnfn max(char8 x, char8 y);

uchar8 __ovld __cnfn max(uchar8 x, uchar8 y);

char16 __ovld __cnfn max(char16 x, char16 y);

uchar16 __ovld __cnfn max(uchar16 x, uchar16 y);

short __ovld __cnfn max(short x, short y);

ushort __ovld __cnfn max(ushort x, ushort y);

short2 __ovld __cnfn max(short2 x, short2 y);

ushort2 __ovld __cnfn max(ushort2 x, ushort2 y);

short3 __ovld __cnfn max(short3 x, short3 y);

ushort3 __ovld __cnfn max(ushort3 x, ushort3 y);

short4 __ovld __cnfn max(short4 x, short4 y);

ushort4 __ovld __cnfn max(ushort4 x, ushort4 y);

short8 __ovld __cnfn max(short8 x, short8 y);

ushort8 __ovld __cnfn max(ushort8 x, ushort8 y);

short16 __ovld __cnfn max(short16 x, short16 y);

ushort16 __ovld __cnfn max(ushort16 x, ushort16 y);

int __ovld __cnfn max(int x, int y);

uint __ovld __cnfn max(uint x, uint y);

int2 __ovld __cnfn max(int2 x, int2 y);

uint2 __ovld __cnfn max(uint2 x, uint2 y);

int3 __ovld __cnfn max(int3 x, int3 y);

uint3 __ovld __cnfn max(uint3 x, uint3 y);

int4 __ovld __cnfn max(int4 x, int4 y);

uint4 __ovld __cnfn max(uint4 x, uint4 y);

int8 __ovld __cnfn max(int8 x, int8 y);

uint8 __ovld __cnfn max(uint8 x, uint8 y);

int16 __ovld __cnfn max(int16 x, int16 y);

uint16 __ovld __cnfn max(uint16 x, uint16 y);

long __ovld __cnfn max(long x, long y);

ulong __ovld __cnfn max(ulong x, ulong y);

long2 __ovld __cnfn max(long2 x, long2 y);

ulong2 __ovld __cnfn max(ulong2 x, ulong2 y);

long3 __ovld __cnfn max(long3 x, long3 y);

ulong3 __ovld __cnfn max(ulong3 x, ulong3 y);

long4 __ovld __cnfn max(long4 x, long4 y);

ulong4 __ovld __cnfn max(ulong4 x, ulong4 y);

long8 __ovld __cnfn max(long8 x, long8 y);

ulong8 __ovld __cnfn max(ulong8 x, ulong8 y);

long16 __ovld __cnfn max(long16 x, long16 y);

ulong16 __ovld __cnfn max(ulong16 x, ulong16 y);

char2 __ovld __cnfn max(char2 x, char y);

uchar2 __ovld __cnfn max(uchar2 x, uchar y);

char3 __ovld __cnfn max(char3 x, char y);

uchar3 __ovld __cnfn max(uchar3 x, uchar y);

char4 __ovld __cnfn max(char4 x, char y);

uchar4 __ovld __cnfn max(uchar4 x, uchar y);

char8 __ovld __cnfn max(char8 x, char y);

uchar8 __ovld __cnfn max(uchar8 x, uchar y);

char16 __ovld __cnfn max(char16 x, char y);

uchar16 __ovld __cnfn max(uchar16 x, uchar y);

short2 __ovld __cnfn max(short2 x, short y);

ushort2 __ovld __cnfn max(ushort2 x, ushort y);

short3 __ovld __cnfn max(short3 x, short y);

ushort3 __ovld __cnfn max(ushort3 x, ushort y);

short4 __ovld __cnfn max(short4 x, short y);

ushort4 __ovld __cnfn max(ushort4 x, ushort y);

short8 __ovld __cnfn max(short8 x, short y);

ushort8 __ovld __cnfn max(ushort8 x, ushort y);

short16 __ovld __cnfn max(short16 x, short y);

ushort16 __ovld __cnfn max(ushort16 x, ushort y);

int2 __ovld __cnfn max(int2 x, int y);

uint2 __ovld __cnfn max(uint2 x, uint y);

int3 __ovld __cnfn max(int3 x, int y);

uint3 __ovld __cnfn max(uint3 x, uint y);

int4 __ovld __cnfn max(int4 x, int y);

uint4 __ovld __cnfn max(uint4 x, uint y);

int8 __ovld __cnfn max(int8 x, int y);

uint8 __ovld __cnfn max(uint8 x, uint y);

int16 __ovld __cnfn max(int16 x, int y);

uint16 __ovld __cnfn max(uint16 x, uint y);

long2 __ovld __cnfn max(long2 x, long y);

ulong2 __ovld __cnfn max(ulong2 x, ulong y);

long3 __ovld __cnfn max(long3 x, long y);

ulong3 __ovld __cnfn max(ulong3 x, ulong y);

long4 __ovld __cnfn max(long4 x, long y);

ulong4 __ovld __cnfn max(ulong4 x, ulong y);

long8 __ovld __cnfn max(long8 x, long y);

ulong8 __ovld __cnfn max(ulong8 x, ulong y);

long16 __ovld __cnfn max(long16 x, long y);

ulong16 __ovld __cnfn max(ulong16 x, ulong y);


char __ovld __cnfn min(char x, char y);

uchar __ovld __cnfn min(uchar x, uchar y);

char2 __ovld __cnfn min(char2 x, char2 y);

uchar2 __ovld __cnfn min(uchar2 x, uchar2 y);

char3 __ovld __cnfn min(char3 x, char3 y);

uchar3 __ovld __cnfn min(uchar3 x, uchar3 y);

char4 __ovld __cnfn min(char4 x, char4 y);

uchar4 __ovld __cnfn min(uchar4 x, uchar4 y);

char8 __ovld __cnfn min(char8 x, char8 y);

uchar8 __ovld __cnfn min(uchar8 x, uchar8 y);

char16 __ovld __cnfn min(char16 x, char16 y);

uchar16 __ovld __cnfn min(uchar16 x, uchar16 y);

short __ovld __cnfn min(short x, short y);

ushort __ovld __cnfn min(ushort x, ushort y);

short2 __ovld __cnfn min(short2 x, short2 y);

ushort2 __ovld __cnfn min(ushort2 x, ushort2 y);

short3 __ovld __cnfn min(short3 x, short3 y);

ushort3 __ovld __cnfn min(ushort3 x, ushort3 y);

short4 __ovld __cnfn min(short4 x, short4 y);

ushort4 __ovld __cnfn min(ushort4 x, ushort4 y);

short8 __ovld __cnfn min(short8 x, short8 y);

ushort8 __ovld __cnfn min(ushort8 x, ushort8 y);

short16 __ovld __cnfn min(short16 x, short16 y);

ushort16 __ovld __cnfn min(ushort16 x, ushort16 y);

int __ovld __cnfn min(int x, int y);

uint __ovld __cnfn min(uint x, uint y);

int2 __ovld __cnfn min(int2 x, int2 y);

uint2 __ovld __cnfn min(uint2 x, uint2 y);

int3 __ovld __cnfn min(int3 x, int3 y);

uint3 __ovld __cnfn min(uint3 x, uint3 y);

int4 __ovld __cnfn min(int4 x, int4 y);

uint4 __ovld __cnfn min(uint4 x, uint4 y);

int8 __ovld __cnfn min(int8 x, int8 y);

uint8 __ovld __cnfn min(uint8 x, uint8 y);

int16 __ovld __cnfn min(int16 x, int16 y);

uint16 __ovld __cnfn min(uint16 x, uint16 y);

long __ovld __cnfn min(long x, long y);

ulong __ovld __cnfn min(ulong x, ulong y);

long2 __ovld __cnfn min(long2 x, long2 y);

ulong2 __ovld __cnfn min(ulong2 x, ulong2 y);

long3 __ovld __cnfn min(long3 x, long3 y);

ulong3 __ovld __cnfn min(ulong3 x, ulong3 y);

long4 __ovld __cnfn min(long4 x, long4 y);

ulong4 __ovld __cnfn min(ulong4 x, ulong4 y);

long8 __ovld __cnfn min(long8 x, long8 y);

ulong8 __ovld __cnfn min(ulong8 x, ulong8 y);

long16 __ovld __cnfn min(long16 x, long16 y);

ulong16 __ovld __cnfn min(ulong16 x, ulong16 y);

char2 __ovld __cnfn min(char2 x, char y);

uchar2 __ovld __cnfn min(uchar2 x, uchar y);

char3 __ovld __cnfn min(char3 x, char y);

uchar3 __ovld __cnfn min(uchar3 x, uchar y);

char4 __ovld __cnfn min(char4 x, char y);

uchar4 __ovld __cnfn min(uchar4 x, uchar y);

char8 __ovld __cnfn min(char8 x, char y);

uchar8 __ovld __cnfn min(uchar8 x, uchar y);

char16 __ovld __cnfn min(char16 x, char y);

uchar16 __ovld __cnfn min(uchar16 x, uchar y);

short2 __ovld __cnfn min(short2 x, short y);

ushort2 __ovld __cnfn min(ushort2 x, ushort y);

short3 __ovld __cnfn min(short3 x, short y);

ushort3 __ovld __cnfn min(ushort3 x, ushort y);

short4 __ovld __cnfn min(short4 x, short y);

ushort4 __ovld __cnfn min(ushort4 x, ushort y);

short8 __ovld __cnfn min(short8 x, short y);

ushort8 __ovld __cnfn min(ushort8 x, ushort y);

short16 __ovld __cnfn min(short16 x, short y);

ushort16 __ovld __cnfn min(ushort16 x, ushort y);

int2 __ovld __cnfn min(int2 x, int y);

uint2 __ovld __cnfn min(uint2 x, uint y);

int3 __ovld __cnfn min(int3 x, int y);

uint3 __ovld __cnfn min(uint3 x, uint y);

int4 __ovld __cnfn min(int4 x, int y);

uint4 __ovld __cnfn min(uint4 x, uint y);

int8 __ovld __cnfn min(int8 x, int y);

uint8 __ovld __cnfn min(uint8 x, uint y);

int16 __ovld __cnfn min(int16 x, int y);

uint16 __ovld __cnfn min(uint16 x, uint y);

long2 __ovld __cnfn min(long2 x, long y);

ulong2 __ovld __cnfn min(ulong2 x, ulong y);

long3 __ovld __cnfn min(long3 x, long y);

ulong3 __ovld __cnfn min(ulong3 x, ulong y);

long4 __ovld __cnfn min(long4 x, long y);

ulong4 __ovld __cnfn min(ulong4 x, ulong y);

long8 __ovld __cnfn min(long8 x, long y);

ulong8 __ovld __cnfn min(ulong8 x, ulong y);

long16 __ovld __cnfn min(long16 x, long y);

ulong16 __ovld __cnfn min(ulong16 x, ulong y);


char __ovld __cnfn mul_hi(char x, char y);

uchar __ovld __cnfn mul_hi(uchar x, uchar y);

char2 __ovld __cnfn mul_hi(char2 x, char2 y);

uchar2 __ovld __cnfn mul_hi(uchar2 x, uchar2 y);

char3 __ovld __cnfn mul_hi(char3 x, char3 y);

uchar3 __ovld __cnfn mul_hi(uchar3 x, uchar3 y);

char4 __ovld __cnfn mul_hi(char4 x, char4 y);

uchar4 __ovld __cnfn mul_hi(uchar4 x, uchar4 y);

char8 __ovld __cnfn mul_hi(char8 x, char8 y);

uchar8 __ovld __cnfn mul_hi(uchar8 x, uchar8 y);

char16 __ovld __cnfn mul_hi(char16 x, char16 y);

uchar16 __ovld __cnfn mul_hi(uchar16 x, uchar16 y);

short __ovld __cnfn mul_hi(short x, short y);

ushort __ovld __cnfn mul_hi(ushort x, ushort y);

short2 __ovld __cnfn mul_hi(short2 x, short2 y);

ushort2 __ovld __cnfn mul_hi(ushort2 x, ushort2 y);

short3 __ovld __cnfn mul_hi(short3 x, short3 y);

ushort3 __ovld __cnfn mul_hi(ushort3 x, ushort3 y);

short4 __ovld __cnfn mul_hi(short4 x, short4 y);

ushort4 __ovld __cnfn mul_hi(ushort4 x, ushort4 y);

short8 __ovld __cnfn mul_hi(short8 x, short8 y);

ushort8 __ovld __cnfn mul_hi(ushort8 x, ushort8 y);

short16 __ovld __cnfn mul_hi(short16 x, short16 y);

ushort16 __ovld __cnfn mul_hi(ushort16 x, ushort16 y);

int __ovld __cnfn mul_hi(int x, int y);

uint __ovld __cnfn mul_hi(uint x, uint y);

int2 __ovld __cnfn mul_hi(int2 x, int2 y);

uint2 __ovld __cnfn mul_hi(uint2 x, uint2 y);

int3 __ovld __cnfn mul_hi(int3 x, int3 y);

uint3 __ovld __cnfn mul_hi(uint3 x, uint3 y);

int4 __ovld __cnfn mul_hi(int4 x, int4 y);

uint4 __ovld __cnfn mul_hi(uint4 x, uint4 y);

int8 __ovld __cnfn mul_hi(int8 x, int8 y);

uint8 __ovld __cnfn mul_hi(uint8 x, uint8 y);

int16 __ovld __cnfn mul_hi(int16 x, int16 y);

uint16 __ovld __cnfn mul_hi(uint16 x, uint16 y);

long __ovld __cnfn mul_hi(long x, long y);

ulong __ovld __cnfn mul_hi(ulong x, ulong y);

long2 __ovld __cnfn mul_hi(long2 x, long2 y);

ulong2 __ovld __cnfn mul_hi(ulong2 x, ulong2 y);

long3 __ovld __cnfn mul_hi(long3 x, long3 y);

ulong3 __ovld __cnfn mul_hi(ulong3 x, ulong3 y);

long4 __ovld __cnfn mul_hi(long4 x, long4 y);

ulong4 __ovld __cnfn mul_hi(ulong4 x, ulong4 y);

long8 __ovld __cnfn mul_hi(long8 x, long8 y);

ulong8 __ovld __cnfn mul_hi(ulong8 x, ulong8 y);

long16 __ovld __cnfn mul_hi(long16 x, long16 y);

ulong16 __ovld __cnfn mul_hi(ulong16 x, ulong16 y);


char __ovld __cnfn rotate(char v, char i);

uchar __ovld __cnfn rotate(uchar v, uchar i);

char2 __ovld __cnfn rotate(char2 v, char2 i);

uchar2 __ovld __cnfn rotate(uchar2 v, uchar2 i);

char3 __ovld __cnfn rotate(char3 v, char3 i);

uchar3 __ovld __cnfn rotate(uchar3 v, uchar3 i);

char4 __ovld __cnfn rotate(char4 v, char4 i);

uchar4 __ovld __cnfn rotate(uchar4 v, uchar4 i);

char8 __ovld __cnfn rotate(char8 v, char8 i);

uchar8 __ovld __cnfn rotate(uchar8 v, uchar8 i);

char16 __ovld __cnfn rotate(char16 v, char16 i);

uchar16 __ovld __cnfn rotate(uchar16 v, uchar16 i);

short __ovld __cnfn rotate(short v, short i);

ushort __ovld __cnfn rotate(ushort v, ushort i);

short2 __ovld __cnfn rotate(short2 v, short2 i);

ushort2 __ovld __cnfn rotate(ushort2 v, ushort2 i);

short3 __ovld __cnfn rotate(short3 v, short3 i);

ushort3 __ovld __cnfn rotate(ushort3 v, ushort3 i);

short4 __ovld __cnfn rotate(short4 v, short4 i);

ushort4 __ovld __cnfn rotate(ushort4 v, ushort4 i);

short8 __ovld __cnfn rotate(short8 v, short8 i);

ushort8 __ovld __cnfn rotate(ushort8 v, ushort8 i);

short16 __ovld __cnfn rotate(short16 v, short16 i);

ushort16 __ovld __cnfn rotate(ushort16 v, ushort16 i);

int __ovld __cnfn rotate(int v, int i);

uint __ovld __cnfn rotate(uint v, uint i);

int2 __ovld __cnfn rotate(int2 v, int2 i);

uint2 __ovld __cnfn rotate(uint2 v, uint2 i);

int3 __ovld __cnfn rotate(int3 v, int3 i);

uint3 __ovld __cnfn rotate(uint3 v, uint3 i);

int4 __ovld __cnfn rotate(int4 v, int4 i);

uint4 __ovld __cnfn rotate(uint4 v, uint4 i);

int8 __ovld __cnfn rotate(int8 v, int8 i);

uint8 __ovld __cnfn rotate(uint8 v, uint8 i);

int16 __ovld __cnfn rotate(int16 v, int16 i);

uint16 __ovld __cnfn rotate(uint16 v, uint16 i);

long __ovld __cnfn rotate(long v, long i);

ulong __ovld __cnfn rotate(ulong v, ulong i);

long2 __ovld __cnfn rotate(long2 v, long2 i);

ulong2 __ovld __cnfn rotate(ulong2 v, ulong2 i);

long3 __ovld __cnfn rotate(long3 v, long3 i);

ulong3 __ovld __cnfn rotate(ulong3 v, ulong3 i);

long4 __ovld __cnfn rotate(long4 v, long4 i);

ulong4 __ovld __cnfn rotate(ulong4 v, ulong4 i);

long8 __ovld __cnfn rotate(long8 v, long8 i);

ulong8 __ovld __cnfn rotate(ulong8 v, ulong8 i);

long16 __ovld __cnfn rotate(long16 v, long16 i);

ulong16 __ovld __cnfn rotate(ulong16 v, ulong16 i);


char __ovld __cnfn sub_sat(char x, char y);

uchar __ovld __cnfn sub_sat(uchar x, uchar y);

char2 __ovld __cnfn sub_sat(char2 x, char2 y);

uchar2 __ovld __cnfn sub_sat(uchar2 x, uchar2 y);

char3 __ovld __cnfn sub_sat(char3 x, char3 y);

uchar3 __ovld __cnfn sub_sat(uchar3 x, uchar3 y);

char4 __ovld __cnfn sub_sat(char4 x, char4 y);

uchar4 __ovld __cnfn sub_sat(uchar4 x, uchar4 y);

char8 __ovld __cnfn sub_sat(char8 x, char8 y);

uchar8 __ovld __cnfn sub_sat(uchar8 x, uchar8 y);

char16 __ovld __cnfn sub_sat(char16 x, char16 y);

uchar16 __ovld __cnfn sub_sat(uchar16 x, uchar16 y);

short __ovld __cnfn sub_sat(short x, short y);

ushort __ovld __cnfn sub_sat(ushort x, ushort y);

short2 __ovld __cnfn sub_sat(short2 x, short2 y);

ushort2 __ovld __cnfn sub_sat(ushort2 x, ushort2 y);

short3 __ovld __cnfn sub_sat(short3 x, short3 y);

ushort3 __ovld __cnfn sub_sat(ushort3 x, ushort3 y);

short4 __ovld __cnfn sub_sat(short4 x, short4 y);

ushort4 __ovld __cnfn sub_sat(ushort4 x, ushort4 y);

short8 __ovld __cnfn sub_sat(short8 x, short8 y);

ushort8 __ovld __cnfn sub_sat(ushort8 x, ushort8 y);

short16 __ovld __cnfn sub_sat(short16 x, short16 y);

ushort16 __ovld __cnfn sub_sat(ushort16 x, ushort16 y);

int __ovld __cnfn sub_sat(int x, int y);

uint __ovld __cnfn sub_sat(uint x, uint y);

int2 __ovld __cnfn sub_sat(int2 x, int2 y);

uint2 __ovld __cnfn sub_sat(uint2 x, uint2 y);

int3 __ovld __cnfn sub_sat(int3 x, int3 y);

uint3 __ovld __cnfn sub_sat(uint3 x, uint3 y);

int4 __ovld __cnfn sub_sat(int4 x, int4 y);

uint4 __ovld __cnfn sub_sat(uint4 x, uint4 y);

int8 __ovld __cnfn sub_sat(int8 x, int8 y);

uint8 __ovld __cnfn sub_sat(uint8 x, uint8 y);

int16 __ovld __cnfn sub_sat(int16 x, int16 y);

uint16 __ovld __cnfn sub_sat(uint16 x, uint16 y);

long __ovld __cnfn sub_sat(long x, long y);

ulong __ovld __cnfn sub_sat(ulong x, ulong y);

long2 __ovld __cnfn sub_sat(long2 x, long2 y);

ulong2 __ovld __cnfn sub_sat(ulong2 x, ulong2 y);

long3 __ovld __cnfn sub_sat(long3 x, long3 y);

ulong3 __ovld __cnfn sub_sat(ulong3 x, ulong3 y);

long4 __ovld __cnfn sub_sat(long4 x, long4 y);

ulong4 __ovld __cnfn sub_sat(ulong4 x, ulong4 y);

long8 __ovld __cnfn sub_sat(long8 x, long8 y);

ulong8 __ovld __cnfn sub_sat(ulong8 x, ulong8 y);

long16 __ovld __cnfn sub_sat(long16 x, long16 y);

ulong16 __ovld __cnfn sub_sat(ulong16 x, ulong16 y);


short __ovld __cnfn upsample(char hi, uchar lo);

ushort __ovld __cnfn upsample(uchar hi, uchar lo);

short2 __ovld __cnfn upsample(char2 hi, uchar2 lo);

short3 __ovld __cnfn upsample(char3 hi, uchar3 lo);

short4 __ovld __cnfn upsample(char4 hi, uchar4 lo);

short8 __ovld __cnfn upsample(char8 hi, uchar8 lo);

short16 __ovld __cnfn upsample(char16 hi, uchar16 lo);

ushort2 __ovld __cnfn upsample(uchar2 hi, uchar2 lo);

ushort3 __ovld __cnfn upsample(uchar3 hi, uchar3 lo);

ushort4 __ovld __cnfn upsample(uchar4 hi, uchar4 lo);

ushort8 __ovld __cnfn upsample(uchar8 hi, uchar8 lo);

ushort16 __ovld __cnfn upsample(uchar16 hi, uchar16 lo);


int __ovld __cnfn upsample(short hi, ushort lo);

uint __ovld __cnfn upsample(ushort hi, ushort lo);

int2 __ovld __cnfn upsample(short2 hi, ushort2 lo);

int3 __ovld __cnfn upsample(short3 hi, ushort3 lo);

int4 __ovld __cnfn upsample(short4 hi, ushort4 lo);

int8 __ovld __cnfn upsample(short8 hi, ushort8 lo);

int16 __ovld __cnfn upsample(short16 hi, ushort16 lo);

uint2 __ovld __cnfn upsample(ushort2 hi, ushort2 lo);

uint3 __ovld __cnfn upsample(ushort3 hi, ushort3 lo);

uint4 __ovld __cnfn upsample(ushort4 hi, ushort4 lo);

uint8 __ovld __cnfn upsample(ushort8 hi, ushort8 lo);

uint16 __ovld __cnfn upsample(ushort16 hi, ushort16 lo);

long __ovld __cnfn upsample(int hi, uint lo);

ulong __ovld __cnfn upsample(uint hi, uint lo);

long2 __ovld __cnfn upsample(int2 hi, uint2 lo);

long3 __ovld __cnfn upsample(int3 hi, uint3 lo);

long4 __ovld __cnfn upsample(int4 hi, uint4 lo);

long8 __ovld __cnfn upsample(int8 hi, uint8 lo);

long16 __ovld __cnfn upsample(int16 hi, uint16 lo);

ulong2 __ovld __cnfn upsample(uint2 hi, uint2 lo);

ulong3 __ovld __cnfn upsample(uint3 hi, uint3 lo);

ulong4 __ovld __cnfn upsample(uint4 hi, uint4 lo);

ulong8 __ovld __cnfn upsample(uint8 hi, uint8 lo);

ulong16 __ovld __cnfn upsample(uint16 hi, uint16 lo);


/*

 * popcount(x): returns the number of set bit in x

 */

char __ovld __cnfn popcount(char x);

uchar __ovld __cnfn popcount(uchar x);

char2 __ovld __cnfn popcount(char2 x);

uchar2 __ovld __cnfn popcount(uchar2 x);

char3 __ovld __cnfn popcount(char3 x);

uchar3 __ovld __cnfn popcount(uchar3 x);

char4 __ovld __cnfn popcount(char4 x);

uchar4 __ovld __cnfn popcount(uchar4 x);

char8 __ovld __cnfn popcount(char8 x);

uchar8 __ovld __cnfn popcount(uchar8 x);

char16 __ovld __cnfn popcount(char16 x);

uchar16 __ovld __cnfn popcount(uchar16 x);

short __ovld __cnfn popcount(short x);

ushort __ovld __cnfn popcount(ushort x);

short2 __ovld __cnfn popcount(short2 x);

ushort2 __ovld __cnfn popcount(ushort2 x);

short3 __ovld __cnfn popcount(short3 x);

ushort3 __ovld __cnfn popcount(ushort3 x);

short4 __ovld __cnfn popcount(short4 x);

ushort4 __ovld __cnfn popcount(ushort4 x);

short8 __ovld __cnfn popcount(short8 x);

ushort8 __ovld __cnfn popcount(ushort8 x);

short16 __ovld __cnfn popcount(short16 x);

ushort16 __ovld __cnfn popcount(ushort16 x);

int __ovld __cnfn popcount(int x);

uint __ovld __cnfn popcount(uint x);

int2 __ovld __cnfn popcount(int2 x);

uint2 __ovld __cnfn popcount(uint2 x);

int3 __ovld __cnfn popcount(int3 x);

uint3 __ovld __cnfn popcount(uint3 x);

int4 __ovld __cnfn popcount(int4 x);

uint4 __ovld __cnfn popcount(uint4 x);

int8 __ovld __cnfn popcount(int8 x);

uint8 __ovld __cnfn popcount(uint8 x);

int16 __ovld __cnfn popcount(int16 x);

uint16 __ovld __cnfn popcount(uint16 x);

long __ovld __cnfn popcount(long x);

ulong __ovld __cnfn popcount(ulong x);

long2 __ovld __cnfn popcount(long2 x);

ulong2 __ovld __cnfn popcount(ulong2 x);

long3 __ovld __cnfn popcount(long3 x);

ulong3 __ovld __cnfn popcount(ulong3 x);

long4 __ovld __cnfn popcount(long4 x);

ulong4 __ovld __cnfn popcount(ulong4 x);

long8 __ovld __cnfn popcount(long8 x);

ulong8 __ovld __cnfn popcount(ulong8 x);

long16 __ovld __cnfn popcount(long16 x);

ulong16 __ovld __cnfn popcount(ulong16 x);


int __ovld __cnfn mad24(int x, int y, int z);

uint __ovld __cnfn mad24(uint x, uint y, uint z);

int2 __ovld __cnfn mad24(int2 x, int2 y, int2 z);

uint2 __ovld __cnfn mad24(uint2 x, uint2 y, uint2 z);

int3 __ovld __cnfn mad24(int3 x, int3 y, int3 z);

uint3 __ovld __cnfn mad24(uint3 x, uint3 y, uint3 z);

int4 __ovld __cnfn mad24(int4 x, int4 y, int4 z);

uint4 __ovld __cnfn mad24(uint4 x, uint4 y, uint4 z);

int8 __ovld __cnfn mad24(int8 x, int8 y, int8 z);

uint8 __ovld __cnfn mad24(uint8 x, uint8 y, uint8 z);

int16 __ovld __cnfn mad24(int16 x, int16 y, int16 z);

uint16 __ovld __cnfn mad24(uint16 x, uint16 y, uint16 z);


int __ovld __cnfn mul24(int x, int y);

uint __ovld __cnfn mul24(uint x, uint y);

int2 __ovld __cnfn mul24(int2 x, int2 y);

uint2 __ovld __cnfn mul24(uint2 x, uint2 y);

int3 __ovld __cnfn mul24(int3 x, int3 y);

uint3 __ovld __cnfn mul24(uint3 x, uint3 y);

int4 __ovld __cnfn mul24(int4 x, int4 y);

uint4 __ovld __cnfn mul24(uint4 x, uint4 y);

int8 __ovld __cnfn mul24(int8 x, int8 y);

uint8 __ovld __cnfn mul24(uint8 x, uint8 y);

int16 __ovld __cnfn mul24(int16 x, int16 y);

uint16 __ovld __cnfn mul24(uint16 x, uint16 y);


// OpenCL v1.1 s6.11.4, v1.2 s6.12.4, v2.0 s6.13.4 - Common Functions


float __ovld __cnfn clamp(float x, float minval, float maxval);

float2 __ovld __cnfn clamp(float2 x, float2 minval, float2 maxval);

float3 __ovld __cnfn clamp(float3 x, float3 minval, float3 maxval);

float4 __ovld __cnfn clamp(float4 x, float4 minval, float4 maxval);

float8 __ovld __cnfn clamp(float8 x, float8 minval, float8 maxval);

float16 __ovld __cnfn clamp(float16 x, float16 minval, float16 maxval);

float2 __ovld __cnfn clamp(float2 x, float minval, float maxval);

float3 __ovld __cnfn clamp(float3 x, float minval, float maxval);

float4 __ovld __cnfn clamp(float4 x, float minval, float maxval);

float8 __ovld __cnfn clamp(float8 x, float minval, float maxval);

float16 __ovld __cnfn clamp(float16 x, float minval, float maxval);

#ifdef cl_khr_fp64

double __ovld __cnfn clamp(double x, double minval, double maxval);

double2 __ovld __cnfn clamp(double2 x, double2 minval, double2 maxval);

double3 __ovld __cnfn clamp(double3 x, double3 minval, double3 maxval);

double4 __ovld __cnfn clamp(double4 x, double4 minval, double4 maxval);

double8 __ovld __cnfn clamp(double8 x, double8 minval, double8 maxval);

double16 __ovld __cnfn clamp(double16 x, double16 minval, double16 maxval);

double2 __ovld __cnfn clamp(double2 x, double minval, double maxval);

double3 __ovld __cnfn clamp(double3 x, double minval, double maxval);

double4 __ovld __cnfn clamp(double4 x, double minval, double maxval);

double8 __ovld __cnfn clamp(double8 x, double minval, double maxval);

double16 __ovld __cnfn clamp(double16 x, double minval, double maxval);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn clamp(half x, half minval, half maxval);

half2 __ovld __cnfn clamp(half2 x, half2 minval, half2 maxval);

half3 __ovld __cnfn clamp(half3 x, half3 minval, half3 maxval);

half4 __ovld __cnfn clamp(half4 x, half4 minval, half4 maxval);

half8 __ovld __cnfn clamp(half8 x, half8 minval, half8 maxval);

half16 __ovld __cnfn clamp(half16 x, half16 minval, half16 maxval);

half2 __ovld __cnfn clamp(half2 x, half minval, half maxval);

half3 __ovld __cnfn clamp(half3 x, half minval, half maxval);

half4 __ovld __cnfn clamp(half4 x, half minval, half maxval);

half8 __ovld __cnfn clamp(half8 x, half minval, half maxval);

half16 __ovld __cnfn clamp(half16 x, half minval, half maxval);

#endif //cl_khr_fp16


float __ovld __cnfn degrees(float radians);

float2 __ovld __cnfn degrees(float2 radians);

float3 __ovld __cnfn degrees(float3 radians);

float4 __ovld __cnfn degrees(float4 radians);

float8 __ovld __cnfn degrees(float8 radians);

float16 __ovld __cnfn degrees(float16 radians);

#ifdef cl_khr_fp64

double __ovld __cnfn degrees(double radians);

double2 __ovld __cnfn degrees(double2 radians);

double3 __ovld __cnfn degrees(double3 radians);

double4 __ovld __cnfn degrees(double4 radians);

double8 __ovld __cnfn degrees(double8 radians);

double16 __ovld __cnfn degrees(double16 radians);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn degrees(half radians);

half2 __ovld __cnfn degrees(half2 radians);

half3 __ovld __cnfn degrees(half3 radians);

half4 __ovld __cnfn degrees(half4 radians);

half8 __ovld __cnfn degrees(half8 radians);

half16 __ovld __cnfn degrees(half16 radians);

#endif //cl_khr_fp16


float __ovld __cnfn max(float x, float y);

float2 __ovld __cnfn max(float2 x, float2 y);

float3 __ovld __cnfn max(float3 x, float3 y);

float4 __ovld __cnfn max(float4 x, float4 y);

float8 __ovld __cnfn max(float8 x, float8 y);

float16 __ovld __cnfn max(float16 x, float16 y);

float2 __ovld __cnfn max(float2 x, float y);

float3 __ovld __cnfn max(float3 x, float y);

float4 __ovld __cnfn max(float4 x, float y);

float8 __ovld __cnfn max(float8 x, float y);

float16 __ovld __cnfn max(float16 x, float y);

#ifdef cl_khr_fp64

double __ovld __cnfn max(double x, double y);

double2 __ovld __cnfn max(double2 x, double2 y);

double3 __ovld __cnfn max(double3 x, double3 y);

double4 __ovld __cnfn max(double4 x, double4 y);

double8 __ovld __cnfn max(double8 x, double8 y);

double16 __ovld __cnfn max(double16 x, double16 y);

double2 __ovld __cnfn max(double2 x, double y);

double3 __ovld __cnfn max(double3 x, double y);

double4 __ovld __cnfn max(double4 x, double y);

double8 __ovld __cnfn max(double8 x, double y);

double16 __ovld __cnfn max(double16 x, double y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn max(half x, half y);

half2 __ovld __cnfn max(half2 x, half2 y);

half3 __ovld __cnfn max(half3 x, half3 y);

half4 __ovld __cnfn max(half4 x, half4 y);

half8 __ovld __cnfn max(half8 x, half8 y);

half16 __ovld __cnfn max(half16 x, half16 y);

half2 __ovld __cnfn max(half2 x, half y);

half3 __ovld __cnfn max(half3 x, half y);

half4 __ovld __cnfn max(half4 x, half y);

half8 __ovld __cnfn max(half8 x, half y);

half16 __ovld __cnfn max(half16 x, half y);

#endif //cl_khr_fp16


float __ovld __cnfn min(float x, float y);

float2 __ovld __cnfn min(float2 x, float2 y);

float3 __ovld __cnfn min(float3 x, float3 y);

float4 __ovld __cnfn min(float4 x, float4 y);

float8 __ovld __cnfn min(float8 x, float8 y);

float16 __ovld __cnfn min(float16 x, float16 y);

float2 __ovld __cnfn min(float2 x, float y);

float3 __ovld __cnfn min(float3 x, float y);

float4 __ovld __cnfn min(float4 x, float y);

float8 __ovld __cnfn min(float8 x, float y);

float16 __ovld __cnfn min(float16 x, float y);

#ifdef cl_khr_fp64

double __ovld __cnfn min(double x, double y);

double2 __ovld __cnfn min(double2 x, double2 y);

double3 __ovld __cnfn min(double3 x, double3 y);

double4 __ovld __cnfn min(double4 x, double4 y);

double8 __ovld __cnfn min(double8 x, double8 y);

double16 __ovld __cnfn min(double16 x, double16 y);

double2 __ovld __cnfn min(double2 x, double y);

double3 __ovld __cnfn min(double3 x, double y);

double4 __ovld __cnfn min(double4 x, double y);

double8 __ovld __cnfn min(double8 x, double y);

double16 __ovld __cnfn min(double16 x, double y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn min(half x, half y);

half2 __ovld __cnfn min(half2 x, half2 y);

half3 __ovld __cnfn min(half3 x, half3 y);

half4 __ovld __cnfn min(half4 x, half4 y);

half8 __ovld __cnfn min(half8 x, half8 y);

half16 __ovld __cnfn min(half16 x, half16 y);

half2 __ovld __cnfn min(half2 x, half y);

half3 __ovld __cnfn min(half3 x, half y);

half4 __ovld __cnfn min(half4 x, half y);

half8 __ovld __cnfn min(half8 x, half y);

half16 __ovld __cnfn min(half16 x, half y);

#endif //cl_khr_fp16


float __ovld __cnfn mix(float x, float y, float a);

float2 __ovld __cnfn mix(float2 x, float2 y, float2 a);

float3 __ovld __cnfn mix(float3 x, float3 y, float3 a);

float4 __ovld __cnfn mix(float4 x, float4 y, float4 a);

float8 __ovld __cnfn mix(float8 x, float8 y, float8 a);

float16 __ovld __cnfn mix(float16 x, float16 y, float16 a);

float2 __ovld __cnfn mix(float2 x, float2 y, float a);

float3 __ovld __cnfn mix(float3 x, float3 y, float a);

float4 __ovld __cnfn mix(float4 x, float4 y, float a);

float8 __ovld __cnfn mix(float8 x, float8 y, float a);

float16 __ovld __cnfn mix(float16 x, float16 y, float a);

#ifdef cl_khr_fp64

double __ovld __cnfn mix(double x, double y, double a);

double2 __ovld __cnfn mix(double2 x, double2 y, double2 a);

double3 __ovld __cnfn mix(double3 x, double3 y, double3 a);

double4 __ovld __cnfn mix(double4 x, double4 y, double4 a);

double8 __ovld __cnfn mix(double8 x, double8 y, double8 a);

double16 __ovld __cnfn mix(double16 x, double16 y, double16 a);

double2 __ovld __cnfn mix(double2 x, double2 y, double a);

double3 __ovld __cnfn mix(double3 x, double3 y, double a);

double4 __ovld __cnfn mix(double4 x, double4 y, double a);

double8 __ovld __cnfn mix(double8 x, double8 y, double a);

double16 __ovld __cnfn mix(double16 x, double16 y, double a);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn mix(half x, half y, half a);

half2 __ovld __cnfn mix(half2 x, half2 y, half2 a);

half3 __ovld __cnfn mix(half3 x, half3 y, half3 a);

half4 __ovld __cnfn mix(half4 x, half4 y, half4 a);

half8 __ovld __cnfn mix(half8 x, half8 y, half8 a);

half16 __ovld __cnfn mix(half16 x, half16 y, half16 a);

half2 __ovld __cnfn mix(half2 x, half2 y, half a);

half3 __ovld __cnfn mix(half3 x, half3 y, half a);

half4 __ovld __cnfn mix(half4 x, half4 y, half a);

half8 __ovld __cnfn mix(half8 x, half8 y, half a);

half16 __ovld __cnfn mix(half16 x, half16 y, half a);

#endif //cl_khr_fp16


float __ovld __cnfn radians(float degrees);

float2 __ovld __cnfn radians(float2 degrees);

float3 __ovld __cnfn radians(float3 degrees);

float4 __ovld __cnfn radians(float4 degrees);

float8 __ovld __cnfn radians(float8 degrees);

float16 __ovld __cnfn radians(float16 degrees);

#ifdef cl_khr_fp64

double __ovld __cnfn radians(double degrees);

double2 __ovld __cnfn radians(double2 degrees);

double3 __ovld __cnfn radians(double3 degrees);

double4 __ovld __cnfn radians(double4 degrees);

double8 __ovld __cnfn radians(double8 degrees);

double16 __ovld __cnfn radians(double16 degrees);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn radians(half degrees);

half2 __ovld __cnfn radians(half2 degrees);

half3 __ovld __cnfn radians(half3 degrees);

half4 __ovld __cnfn radians(half4 degrees);

half8 __ovld __cnfn radians(half8 degrees);

half16 __ovld __cnfn radians(half16 degrees);

#endif //cl_khr_fp16


float __ovld __cnfn step(float edge, float x);

float2 __ovld __cnfn step(float2 edge, float2 x);

float3 __ovld __cnfn step(float3 edge, float3 x);

float4 __ovld __cnfn step(float4 edge, float4 x);

float8 __ovld __cnfn step(float8 edge, float8 x);

float16 __ovld __cnfn step(float16 edge, float16 x);

float2 __ovld __cnfn step(float edge, float2 x);

float3 __ovld __cnfn step(float edge, float3 x);

float4 __ovld __cnfn step(float edge, float4 x);

float8 __ovld __cnfn step(float edge, float8 x);

float16 __ovld __cnfn step(float edge, float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn step(double edge, double x);

double2 __ovld __cnfn step(double2 edge, double2 x);

double3 __ovld __cnfn step(double3 edge, double3 x);

double4 __ovld __cnfn step(double4 edge, double4 x);

double8 __ovld __cnfn step(double8 edge, double8 x);

double16 __ovld __cnfn step(double16 edge, double16 x);

double2 __ovld __cnfn step(double edge, double2 x);

double3 __ovld __cnfn step(double edge, double3 x);

double4 __ovld __cnfn step(double edge, double4 x);

double8 __ovld __cnfn step(double edge, double8 x);

double16 __ovld __cnfn step(double edge, double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn step(half edge, half x);

half2 __ovld __cnfn step(half2 edge, half2 x);

half3 __ovld __cnfn step(half3 edge, half3 x);

half4 __ovld __cnfn step(half4 edge, half4 x);

half8 __ovld __cnfn step(half8 edge, half8 x);

half16 __ovld __cnfn step(half16 edge, half16 x);

half2 __ovld __cnfn step(half edge, half2 x);

half3 __ovld __cnfn step(half edge, half3 x);

half4 __ovld __cnfn step(half edge, half4 x);

half8 __ovld __cnfn step(half edge, half8 x);

half16 __ovld __cnfn step(half edge, half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn smoothstep(float edge0, float edge1, float x);

float2 __ovld __cnfn smoothstep(float2 edge0, float2 edge1, float2 x);

float3 __ovld __cnfn smoothstep(float3 edge0, float3 edge1, float3 x);

float4 __ovld __cnfn smoothstep(float4 edge0, float4 edge1, float4 x);

float8 __ovld __cnfn smoothstep(float8 edge0, float8 edge1, float8 x);

float16 __ovld __cnfn smoothstep(float16 edge0, float16 edge1, float16 x);

float2 __ovld __cnfn smoothstep(float edge0, float edge1, float2 x);

float3 __ovld __cnfn smoothstep(float edge0, float edge1, float3 x);

float4 __ovld __cnfn smoothstep(float edge0, float edge1, float4 x);

float8 __ovld __cnfn smoothstep(float edge0, float edge1, float8 x);

float16 __ovld __cnfn smoothstep(float edge0, float edge1, float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn smoothstep(double edge0, double edge1, double x);

double2 __ovld __cnfn smoothstep(double2 edge0, double2 edge1, double2 x);

double3 __ovld __cnfn smoothstep(double3 edge0, double3 edge1, double3 x);

double4 __ovld __cnfn smoothstep(double4 edge0, double4 edge1, double4 x);

double8 __ovld __cnfn smoothstep(double8 edge0, double8 edge1, double8 x);

double16 __ovld __cnfn smoothstep(double16 edge0, double16 edge1, double16 x);

double2 __ovld __cnfn smoothstep(double edge0, double edge1, double2 x);

double3 __ovld __cnfn smoothstep(double edge0, double edge1, double3 x);

double4 __ovld __cnfn smoothstep(double edge0, double edge1, double4 x);

double8 __ovld __cnfn smoothstep(double edge0, double edge1, double8 x);

double16 __ovld __cnfn smoothstep(double edge0, double edge1, double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn smoothstep(half edge0, half edge1, half x);

half2 __ovld __cnfn smoothstep(half2 edge0, half2 edge1, half2 x);

half3 __ovld __cnfn smoothstep(half3 edge0, half3 edge1, half3 x);

half4 __ovld __cnfn smoothstep(half4 edge0, half4 edge1, half4 x);

half8 __ovld __cnfn smoothstep(half8 edge0, half8 edge1, half8 x);

half16 __ovld __cnfn smoothstep(half16 edge0, half16 edge1, half16 x);

half2 __ovld __cnfn smoothstep(half edge0, half edge1, half2 x);

half3 __ovld __cnfn smoothstep(half edge0, half edge1, half3 x);

half4 __ovld __cnfn smoothstep(half edge0, half edge1, half4 x);

half8 __ovld __cnfn smoothstep(half edge0, half edge1, half8 x);

half16 __ovld __cnfn smoothstep(half edge0, half edge1, half16 x);

#endif //cl_khr_fp16


float __ovld __cnfn sign(float x);

float2 __ovld __cnfn sign(float2 x);

float3 __ovld __cnfn sign(float3 x);

float4 __ovld __cnfn sign(float4 x);

float8 __ovld __cnfn sign(float8 x);

float16 __ovld __cnfn sign(float16 x);

#ifdef cl_khr_fp64

double __ovld __cnfn sign(double x);

double2 __ovld __cnfn sign(double2 x);

double3 __ovld __cnfn sign(double3 x);

double4 __ovld __cnfn sign(double4 x);

double8 __ovld __cnfn sign(double8 x);

double16 __ovld __cnfn sign(double16 x);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn sign(half x);

half2 __ovld __cnfn sign(half2 x);

half3 __ovld __cnfn sign(half3 x);

half4 __ovld __cnfn sign(half4 x);

half8 __ovld __cnfn sign(half8 x);

half16 __ovld __cnfn sign(half16 x);

#endif //cl_khr_fp16


// OpenCL v1.1 s6.11.5, v1.2 s6.12.5, v2.0 s6.13.5 - Geometric Functions


float4 __ovld __cnfn cross(float4 p0, float4 p1);

float3 __ovld __cnfn cross(float3 p0, float3 p1);

#ifdef cl_khr_fp64

double4 __ovld __cnfn cross(double4 p0, double4 p1);

double3 __ovld __cnfn cross(double3 p0, double3 p1);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half4 __ovld __cnfn cross(half4 p0, half4 p1);

half3 __ovld __cnfn cross(half3 p0, half3 p1);

#endif //cl_khr_fp16


float __ovld __cnfn dot(float p0, float p1);

float __ovld __cnfn dot(float2 p0, float2 p1);

float __ovld __cnfn dot(float3 p0, float3 p1);

float __ovld __cnfn dot(float4 p0, float4 p1);

#ifdef cl_khr_fp64

double __ovld __cnfn dot(double p0, double p1);

double __ovld __cnfn dot(double2 p0, double2 p1);

double __ovld __cnfn dot(double3 p0, double3 p1);

double __ovld __cnfn dot(double4 p0, double4 p1);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn dot(half p0, half p1);

half __ovld __cnfn dot(half2 p0, half2 p1);

half __ovld __cnfn dot(half3 p0, half3 p1);

half __ovld __cnfn dot(half4 p0, half4 p1);

#endif //cl_khr_fp16


float __ovld __cnfn distance(float p0, float p1);

float __ovld __cnfn distance(float2 p0, float2 p1);

float __ovld __cnfn distance(float3 p0, float3 p1);

float __ovld __cnfn distance(float4 p0, float4 p1);

#ifdef cl_khr_fp64

double __ovld __cnfn distance(double p0, double p1);

double __ovld __cnfn distance(double2 p0, double2 p1);

double __ovld __cnfn distance(double3 p0, double3 p1);

double __ovld __cnfn distance(double4 p0, double4 p1);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn distance(half p0, half p1);

half __ovld __cnfn distance(half2 p0, half2 p1);

half __ovld __cnfn distance(half3 p0, half3 p1);

half __ovld __cnfn distance(half4 p0, half4 p1);

#endif //cl_khr_fp16


float __ovld __cnfn length(float p);

float __ovld __cnfn length(float2 p);

float __ovld __cnfn length(float3 p);

float __ovld __cnfn length(float4 p);

#ifdef cl_khr_fp64

double __ovld __cnfn length(double p);

double __ovld __cnfn length(double2 p);

double __ovld __cnfn length(double3 p);

double __ovld __cnfn length(double4 p);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn length(half p);

half __ovld __cnfn length(half2 p);

half __ovld __cnfn length(half3 p);

half __ovld __cnfn length(half4 p);

#endif //cl_khr_fp16


float __ovld __cnfn normalize(float p);

float2 __ovld __cnfn normalize(float2 p);

float3 __ovld __cnfn normalize(float3 p);

float4 __ovld __cnfn normalize(float4 p);

#ifdef cl_khr_fp64

double __ovld __cnfn normalize(double p);

double2 __ovld __cnfn normalize(double2 p);

double3 __ovld __cnfn normalize(double3 p);

double4 __ovld __cnfn normalize(double4 p);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn normalize(half p);

half2 __ovld __cnfn normalize(half2 p);

half3 __ovld __cnfn normalize(half3 p);

half4 __ovld __cnfn normalize(half4 p);

#endif //cl_khr_fp16


float __ovld __cnfn fast_distance(float p0, float p1);

float __ovld __cnfn fast_distance(float2 p0, float2 p1);

float __ovld __cnfn fast_distance(float3 p0, float3 p1);

float __ovld __cnfn fast_distance(float4 p0, float4 p1);

#ifdef cl_khr_fp16

half __ovld __cnfn fast_distance(half p0, half p1);

half __ovld __cnfn fast_distance(half2 p0, half2 p1);

half __ovld __cnfn fast_distance(half3 p0, half3 p1);

half __ovld __cnfn fast_distance(half4 p0, half4 p1);

#endif //cl_khr_fp16


float __ovld __cnfn fast_length(float p);

float __ovld __cnfn fast_length(float2 p);

float __ovld __cnfn fast_length(float3 p);

float __ovld __cnfn fast_length(float4 p);

#ifdef cl_khr_fp16

half __ovld __cnfn fast_length(half p);

half __ovld __cnfn fast_length(half2 p);

half __ovld __cnfn fast_length(half3 p);

half __ovld __cnfn fast_length(half4 p);

#endif //cl_khr_fp16


float __ovld __cnfn fast_normalize(float p);

float2 __ovld __cnfn fast_normalize(float2 p);

float3 __ovld __cnfn fast_normalize(float3 p);

float4 __ovld __cnfn fast_normalize(float4 p);

#ifdef cl_khr_fp16

half __ovld __cnfn fast_normalize(half p);

half2 __ovld __cnfn fast_normalize(half2 p);

half3 __ovld __cnfn fast_normalize(half3 p);

half4 __ovld __cnfn fast_normalize(half4 p);

#endif //cl_khr_fp16


// OpenCL v1.1 s6.11.6, v1.2 s6.12.6, v2.0 s6.13.6 - Relational Functions


int __ovld __cnfn isequal(float x, float y);

int2 __ovld __cnfn isequal(float2 x, float2 y);

int3 __ovld __cnfn isequal(float3 x, float3 y);

int4 __ovld __cnfn isequal(float4 x, float4 y);

int8 __ovld __cnfn isequal(float8 x, float8 y);

int16 __ovld __cnfn isequal(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isequal(double x, double y);

long2 __ovld __cnfn isequal(double2 x, double2 y);

long3 __ovld __cnfn isequal(double3 x, double3 y);

long4 __ovld __cnfn isequal(double4 x, double4 y);

long8 __ovld __cnfn isequal(double8 x, double8 y);

long16 __ovld __cnfn isequal(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isequal(half x, half y);

short2 __ovld __cnfn isequal(half2 x, half2 y);

short3 __ovld __cnfn isequal(half3 x, half3 y);

short4 __ovld __cnfn isequal(half4 x, half4 y);

short8 __ovld __cnfn isequal(half8 x, half8 y);

short16 __ovld __cnfn isequal(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn isnotequal(float x, float y);

int2 __ovld __cnfn isnotequal(float2 x, float2 y);

int3 __ovld __cnfn isnotequal(float3 x, float3 y);

int4 __ovld __cnfn isnotequal(float4 x, float4 y);

int8 __ovld __cnfn isnotequal(float8 x, float8 y);

int16 __ovld __cnfn isnotequal(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isnotequal(double x, double y);

long2 __ovld __cnfn isnotequal(double2 x, double2 y);

long3 __ovld __cnfn isnotequal(double3 x, double3 y);

long4 __ovld __cnfn isnotequal(double4 x, double4 y);

long8 __ovld __cnfn isnotequal(double8 x, double8 y);

long16 __ovld __cnfn isnotequal(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isnotequal(half x, half y);

short2 __ovld __cnfn isnotequal(half2 x, half2 y);

short3 __ovld __cnfn isnotequal(half3 x, half3 y);

short4 __ovld __cnfn isnotequal(half4 x, half4 y);

short8 __ovld __cnfn isnotequal(half8 x, half8 y);

short16 __ovld __cnfn isnotequal(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn isgreater(float x, float y);

int2 __ovld __cnfn isgreater(float2 x, float2 y);

int3 __ovld __cnfn isgreater(float3 x, float3 y);

int4 __ovld __cnfn isgreater(float4 x, float4 y);

int8 __ovld __cnfn isgreater(float8 x, float8 y);

int16 __ovld __cnfn isgreater(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isgreater(double x, double y);

long2 __ovld __cnfn isgreater(double2 x, double2 y);

long3 __ovld __cnfn isgreater(double3 x, double3 y);

long4 __ovld __cnfn isgreater(double4 x, double4 y);

long8 __ovld __cnfn isgreater(double8 x, double8 y);

long16 __ovld __cnfn isgreater(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isgreater(half x, half y);

short2 __ovld __cnfn isgreater(half2 x, half2 y);

short3 __ovld __cnfn isgreater(half3 x, half3 y);

short4 __ovld __cnfn isgreater(half4 x, half4 y);

short8 __ovld __cnfn isgreater(half8 x, half8 y);

short16 __ovld __cnfn isgreater(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn isgreaterequal(float x, float y);

int2 __ovld __cnfn isgreaterequal(float2 x, float2 y);

int3 __ovld __cnfn isgreaterequal(float3 x, float3 y);

int4 __ovld __cnfn isgreaterequal(float4 x, float4 y);

int8 __ovld __cnfn isgreaterequal(float8 x, float8 y);

int16 __ovld __cnfn isgreaterequal(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isgreaterequal(double x, double y);

long2 __ovld __cnfn isgreaterequal(double2 x, double2 y);

long3 __ovld __cnfn isgreaterequal(double3 x, double3 y);

long4 __ovld __cnfn isgreaterequal(double4 x, double4 y);

long8 __ovld __cnfn isgreaterequal(double8 x, double8 y);

long16 __ovld __cnfn isgreaterequal(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isgreaterequal(half x, half y);

short2 __ovld __cnfn isgreaterequal(half2 x, half2 y);

short3 __ovld __cnfn isgreaterequal(half3 x, half3 y);

short4 __ovld __cnfn isgreaterequal(half4 x, half4 y);

short8 __ovld __cnfn isgreaterequal(half8 x, half8 y);

short16 __ovld __cnfn isgreaterequal(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn isless(float x, float y);

int2 __ovld __cnfn isless(float2 x, float2 y);

int3 __ovld __cnfn isless(float3 x, float3 y);

int4 __ovld __cnfn isless(float4 x, float4 y);

int8 __ovld __cnfn isless(float8 x, float8 y);

int16 __ovld __cnfn isless(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isless(double x, double y);

long2 __ovld __cnfn isless(double2 x, double2 y);

long3 __ovld __cnfn isless(double3 x, double3 y);

long4 __ovld __cnfn isless(double4 x, double4 y);

long8 __ovld __cnfn isless(double8 x, double8 y);

long16 __ovld __cnfn isless(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isless(half x, half y);

short2 __ovld __cnfn isless(half2 x, half2 y);

short3 __ovld __cnfn isless(half3 x, half3 y);

short4 __ovld __cnfn isless(half4 x, half4 y);

short8 __ovld __cnfn isless(half8 x, half8 y);

short16 __ovld __cnfn isless(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn islessequal(float x, float y);

int2 __ovld __cnfn islessequal(float2 x, float2 y);

int3 __ovld __cnfn islessequal(float3 x, float3 y);

int4 __ovld __cnfn islessequal(float4 x, float4 y);

int8 __ovld __cnfn islessequal(float8 x, float8 y);

int16 __ovld __cnfn islessequal(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn islessequal(double x, double y);

long2 __ovld __cnfn islessequal(double2 x, double2 y);

long3 __ovld __cnfn islessequal(double3 x, double3 y);

long4 __ovld __cnfn islessequal(double4 x, double4 y);

long8 __ovld __cnfn islessequal(double8 x, double8 y);

long16 __ovld __cnfn islessequal(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn islessequal(half x, half y);

short2 __ovld __cnfn islessequal(half2 x, half2 y);

short3 __ovld __cnfn islessequal(half3 x, half3 y);

short4 __ovld __cnfn islessequal(half4 x, half4 y);

short8 __ovld __cnfn islessequal(half8 x, half8 y);

short16 __ovld __cnfn islessequal(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn islessgreater(float x, float y);

int2 __ovld __cnfn islessgreater(float2 x, float2 y);

int3 __ovld __cnfn islessgreater(float3 x, float3 y);

int4 __ovld __cnfn islessgreater(float4 x, float4 y);

int8 __ovld __cnfn islessgreater(float8 x, float8 y);

int16 __ovld __cnfn islessgreater(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn islessgreater(double x, double y);

long2 __ovld __cnfn islessgreater(double2 x, double2 y);

long3 __ovld __cnfn islessgreater(double3 x, double3 y);

long4 __ovld __cnfn islessgreater(double4 x, double4 y);

long8 __ovld __cnfn islessgreater(double8 x, double8 y);

long16 __ovld __cnfn islessgreater(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn islessgreater(half x, half y);

short2 __ovld __cnfn islessgreater(half2 x, half2 y);

short3 __ovld __cnfn islessgreater(half3 x, half3 y);

short4 __ovld __cnfn islessgreater(half4 x, half4 y);

short8 __ovld __cnfn islessgreater(half8 x, half8 y);

short16 __ovld __cnfn islessgreater(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn isfinite(float);

int2 __ovld __cnfn isfinite(float2);

int3 __ovld __cnfn isfinite(float3);

int4 __ovld __cnfn isfinite(float4);

int8 __ovld __cnfn isfinite(float8);

int16 __ovld __cnfn isfinite(float16);

#ifdef cl_khr_fp64

int __ovld __cnfn isfinite(double);

long2 __ovld __cnfn isfinite(double2);

long3 __ovld __cnfn isfinite(double3);

long4 __ovld __cnfn isfinite(double4);

long8 __ovld __cnfn isfinite(double8);

long16 __ovld __cnfn isfinite(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isfinite(half);

short2 __ovld __cnfn isfinite(half2);

short3 __ovld __cnfn isfinite(half3);

short4 __ovld __cnfn isfinite(half4);

short8 __ovld __cnfn isfinite(half8);

short16 __ovld __cnfn isfinite(half16);

#endif //cl_khr_fp16


int __ovld __cnfn isinf(float);

int2 __ovld __cnfn isinf(float2);

int3 __ovld __cnfn isinf(float3);

int4 __ovld __cnfn isinf(float4);

int8 __ovld __cnfn isinf(float8);

int16 __ovld __cnfn isinf(float16);

#ifdef cl_khr_fp64

int __ovld __cnfn isinf(double);

long2 __ovld __cnfn isinf(double2);

long3 __ovld __cnfn isinf(double3);

long4 __ovld __cnfn isinf(double4);

long8 __ovld __cnfn isinf(double8);

long16 __ovld __cnfn isinf(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isinf(half);

short2 __ovld __cnfn isinf(half2);

short3 __ovld __cnfn isinf(half3);

short4 __ovld __cnfn isinf(half4);

short8 __ovld __cnfn isinf(half8);

short16 __ovld __cnfn isinf(half16);

#endif //cl_khr_fp16


int __ovld __cnfn isnan(float);

int2 __ovld __cnfn isnan(float2);

int3 __ovld __cnfn isnan(float3);

int4 __ovld __cnfn isnan(float4);

int8 __ovld __cnfn isnan(float8);

int16 __ovld __cnfn isnan(float16);

#ifdef cl_khr_fp64

int __ovld __cnfn isnan(double);

long2 __ovld __cnfn isnan(double2);

long3 __ovld __cnfn isnan(double3);

long4 __ovld __cnfn isnan(double4);

long8 __ovld __cnfn isnan(double8);

long16 __ovld __cnfn isnan(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isnan(half);

short2 __ovld __cnfn isnan(half2);

short3 __ovld __cnfn isnan(half3);

short4 __ovld __cnfn isnan(half4);

short8 __ovld __cnfn isnan(half8);

short16 __ovld __cnfn isnan(half16);

#endif //cl_khr_fp16


int __ovld __cnfn isnormal(float);

int2 __ovld __cnfn isnormal(float2);

int3 __ovld __cnfn isnormal(float3);

int4 __ovld __cnfn isnormal(float4);

int8 __ovld __cnfn isnormal(float8);

int16 __ovld __cnfn isnormal(float16);

#ifdef cl_khr_fp64

int __ovld __cnfn isnormal(double);

long2 __ovld __cnfn isnormal(double2);

long3 __ovld __cnfn isnormal(double3);

long4 __ovld __cnfn isnormal(double4);

long8 __ovld __cnfn isnormal(double8);

long16 __ovld __cnfn isnormal(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isnormal(half);

short2 __ovld __cnfn isnormal(half2);

short3 __ovld __cnfn isnormal(half3);

short4 __ovld __cnfn isnormal(half4);

short8 __ovld __cnfn isnormal(half8);

short16 __ovld __cnfn isnormal(half16);

#endif //cl_khr_fp16


int __ovld __cnfn isordered(float x, float y);

int2 __ovld __cnfn isordered(float2 x, float2 y);

int3 __ovld __cnfn isordered(float3 x, float3 y);

int4 __ovld __cnfn isordered(float4 x, float4 y);

int8 __ovld __cnfn isordered(float8 x, float8 y);

int16 __ovld __cnfn isordered(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isordered(double x, double y);

long2 __ovld __cnfn isordered(double2 x, double2 y);

long3 __ovld __cnfn isordered(double3 x, double3 y);

long4 __ovld __cnfn isordered(double4 x, double4 y);

long8 __ovld __cnfn isordered(double8 x, double8 y);

long16 __ovld __cnfn isordered(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isordered(half x, half y);

short2 __ovld __cnfn isordered(half2 x, half2 y);

short3 __ovld __cnfn isordered(half3 x, half3 y);

short4 __ovld __cnfn isordered(half4 x, half4 y);

short8 __ovld __cnfn isordered(half8 x, half8 y);

short16 __ovld __cnfn isordered(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn isunordered(float x, float y);

int2 __ovld __cnfn isunordered(float2 x, float2 y);

int3 __ovld __cnfn isunordered(float3 x, float3 y);

int4 __ovld __cnfn isunordered(float4 x, float4 y);

int8 __ovld __cnfn isunordered(float8 x, float8 y);

int16 __ovld __cnfn isunordered(float16 x, float16 y);

#ifdef cl_khr_fp64

int __ovld __cnfn isunordered(double x, double y);

long2 __ovld __cnfn isunordered(double2 x, double2 y);

long3 __ovld __cnfn isunordered(double3 x, double3 y);

long4 __ovld __cnfn isunordered(double4 x, double4 y);

long8 __ovld __cnfn isunordered(double8 x, double8 y);

long16 __ovld __cnfn isunordered(double16 x, double16 y);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn isunordered(half x, half y);

short2 __ovld __cnfn isunordered(half2 x, half2 y);

short3 __ovld __cnfn isunordered(half3 x, half3 y);

short4 __ovld __cnfn isunordered(half4 x, half4 y);

short8 __ovld __cnfn isunordered(half8 x, half8 y);

short16 __ovld __cnfn isunordered(half16 x, half16 y);

#endif //cl_khr_fp16


int __ovld __cnfn signbit(float);

int2 __ovld __cnfn signbit(float2);

int3 __ovld __cnfn signbit(float3);

int4 __ovld __cnfn signbit(float4);

int8 __ovld __cnfn signbit(float8);

int16 __ovld __cnfn signbit(float16);

#ifdef cl_khr_fp64

int __ovld __cnfn signbit(double);

long2 __ovld __cnfn signbit(double2);

long3 __ovld __cnfn signbit(double3);

long4 __ovld __cnfn signbit(double4);

long8 __ovld __cnfn signbit(double8);

long16 __ovld __cnfn signbit(double16);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

int __ovld __cnfn signbit(half);

short2 __ovld __cnfn signbit(half2);

short3 __ovld __cnfn signbit(half3);

short4 __ovld __cnfn signbit(half4);

short8 __ovld __cnfn signbit(half8);

short16 __ovld __cnfn signbit(half16);

#endif //cl_khr_fp16


int __ovld __cnfn any(char x);

int __ovld __cnfn any(char2 x);

int __ovld __cnfn any(char3 x);

int __ovld __cnfn any(char4 x);

int __ovld __cnfn any(char8 x);

int __ovld __cnfn any(char16 x);

int __ovld __cnfn any(short x);

int __ovld __cnfn any(short2 x);

int __ovld __cnfn any(short3 x);

int __ovld __cnfn any(short4 x);

int __ovld __cnfn any(short8 x);

int __ovld __cnfn any(short16 x);

int __ovld __cnfn any(int x);

int __ovld __cnfn any(int2 x);

int __ovld __cnfn any(int3 x);

int __ovld __cnfn any(int4 x);

int __ovld __cnfn any(int8 x);

int __ovld __cnfn any(int16 x);

int __ovld __cnfn any(long x);

int __ovld __cnfn any(long2 x);

int __ovld __cnfn any(long3 x);

int __ovld __cnfn any(long4 x);

int __ovld __cnfn any(long8 x);

int __ovld __cnfn any(long16 x);


int __ovld __cnfn all(char x);

int __ovld __cnfn all(char2 x);

int __ovld __cnfn all(char3 x);

int __ovld __cnfn all(char4 x);

int __ovld __cnfn all(char8 x);

int __ovld __cnfn all(char16 x);

int __ovld __cnfn all(short x);

int __ovld __cnfn all(short2 x);

int __ovld __cnfn all(short3 x);

int __ovld __cnfn all(short4 x);

int __ovld __cnfn all(short8 x);

int __ovld __cnfn all(short16 x);

int __ovld __cnfn all(int x);

int __ovld __cnfn all(int2 x);

int __ovld __cnfn all(int3 x);

int __ovld __cnfn all(int4 x);

int __ovld __cnfn all(int8 x);

int __ovld __cnfn all(int16 x);

int __ovld __cnfn all(long x);

int __ovld __cnfn all(long2 x);

int __ovld __cnfn all(long3 x);

int __ovld __cnfn all(long4 x);

int __ovld __cnfn all(long8 x);

int __ovld __cnfn all(long16 x);


char __ovld __cnfn bitselect(char a, char b, char c);

uchar __ovld __cnfn bitselect(uchar a, uchar b, uchar c);

char2 __ovld __cnfn bitselect(char2 a, char2 b, char2 c);

uchar2 __ovld __cnfn bitselect(uchar2 a, uchar2 b, uchar2 c);

char3 __ovld __cnfn bitselect(char3 a, char3 b, char3 c);

uchar3 __ovld __cnfn bitselect(uchar3 a, uchar3 b, uchar3 c);

char4 __ovld __cnfn bitselect(char4 a, char4 b, char4 c);

uchar4 __ovld __cnfn bitselect(uchar4 a, uchar4 b, uchar4 c);

char8 __ovld __cnfn bitselect(char8 a, char8 b, char8 c);

uchar8 __ovld __cnfn bitselect(uchar8 a, uchar8 b, uchar8 c);

char16 __ovld __cnfn bitselect(char16 a, char16 b, char16 c);

uchar16 __ovld __cnfn bitselect(uchar16 a, uchar16 b, uchar16 c);

short __ovld __cnfn bitselect(short a, short b, short c);

ushort __ovld __cnfn bitselect(ushort a, ushort b, ushort c);

short2 __ovld __cnfn bitselect(short2 a, short2 b, short2 c);

ushort2 __ovld __cnfn bitselect(ushort2 a, ushort2 b, ushort2 c);

short3 __ovld __cnfn bitselect(short3 a, short3 b, short3 c);

ushort3 __ovld __cnfn bitselect(ushort3 a, ushort3 b, ushort3 c);

short4 __ovld __cnfn bitselect(short4 a, short4 b, short4 c);

ushort4 __ovld __cnfn bitselect(ushort4 a, ushort4 b, ushort4 c);

short8 __ovld __cnfn bitselect(short8 a, short8 b, short8 c);

ushort8 __ovld __cnfn bitselect(ushort8 a, ushort8 b, ushort8 c);

short16 __ovld __cnfn bitselect(short16 a, short16 b, short16 c);

ushort16 __ovld __cnfn bitselect(ushort16 a, ushort16 b, ushort16 c);

int __ovld __cnfn bitselect(int a, int b, int c);

uint __ovld __cnfn bitselect(uint a, uint b, uint c);

int2 __ovld __cnfn bitselect(int2 a, int2 b, int2 c);

uint2 __ovld __cnfn bitselect(uint2 a, uint2 b, uint2 c);

int3 __ovld __cnfn bitselect(int3 a, int3 b, int3 c);

uint3 __ovld __cnfn bitselect(uint3 a, uint3 b, uint3 c);

int4 __ovld __cnfn bitselect(int4 a, int4 b, int4 c);

uint4 __ovld __cnfn bitselect(uint4 a, uint4 b, uint4 c);

int8 __ovld __cnfn bitselect(int8 a, int8 b, int8 c);

uint8 __ovld __cnfn bitselect(uint8 a, uint8 b, uint8 c);

int16 __ovld __cnfn bitselect(int16 a, int16 b, int16 c);

uint16 __ovld __cnfn bitselect(uint16 a, uint16 b, uint16 c);

long __ovld __cnfn bitselect(long a, long b, long c);

ulong __ovld __cnfn bitselect(ulong a, ulong b, ulong c);

long2 __ovld __cnfn bitselect(long2 a, long2 b, long2 c);

ulong2 __ovld __cnfn bitselect(ulong2 a, ulong2 b, ulong2 c);

long3 __ovld __cnfn bitselect(long3 a, long3 b, long3 c);

ulong3 __ovld __cnfn bitselect(ulong3 a, ulong3 b, ulong3 c);

long4 __ovld __cnfn bitselect(long4 a, long4 b, long4 c);

ulong4 __ovld __cnfn bitselect(ulong4 a, ulong4 b, ulong4 c);

long8 __ovld __cnfn bitselect(long8 a, long8 b, long8 c);

ulong8 __ovld __cnfn bitselect(ulong8 a, ulong8 b, ulong8 c);

long16 __ovld __cnfn bitselect(long16 a, long16 b, long16 c);

ulong16 __ovld __cnfn bitselect(ulong16 a, ulong16 b, ulong16 c);

float __ovld __cnfn bitselect(float a, float b, float c);

float2 __ovld __cnfn bitselect(float2 a, float2 b, float2 c);

float3 __ovld __cnfn bitselect(float3 a, float3 b, float3 c);

float4 __ovld __cnfn bitselect(float4 a, float4 b, float4 c);

float8 __ovld __cnfn bitselect(float8 a, float8 b, float8 c);

float16 __ovld __cnfn bitselect(float16 a, float16 b, float16 c);

#ifdef cl_khr_fp64

double __ovld __cnfn bitselect(double a, double b, double c);

double2 __ovld __cnfn bitselect(double2 a, double2 b, double2 c);

double3 __ovld __cnfn bitselect(double3 a, double3 b, double3 c);

double4 __ovld __cnfn bitselect(double4 a, double4 b, double4 c);

double8 __ovld __cnfn bitselect(double8 a, double8 b, double8 c);

double16 __ovld __cnfn bitselect(double16 a, double16 b, double16 c);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn bitselect(half a, half b, half c);

half2 __ovld __cnfn bitselect(half2 a, half2 b, half2 c);

half3 __ovld __cnfn bitselect(half3 a, half3 b, half3 c);

half4 __ovld __cnfn bitselect(half4 a, half4 b, half4 c);

half8 __ovld __cnfn bitselect(half8 a, half8 b, half8 c);

half16 __ovld __cnfn bitselect(half16 a, half16 b, half16 c);

#endif //cl_khr_fp16


char __ovld __cnfn select(char a, char b, char c);

uchar __ovld __cnfn select(uchar a, uchar b, char c);

char2 __ovld __cnfn select(char2 a, char2 b, char2 c);

uchar2 __ovld __cnfn select(uchar2 a, uchar2 b, char2 c);

char3 __ovld __cnfn select(char3 a, char3 b, char3 c);

uchar3 __ovld __cnfn select(uchar3 a, uchar3 b, char3 c);

char4 __ovld __cnfn select(char4 a, char4 b, char4 c);

uchar4 __ovld __cnfn select(uchar4 a, uchar4 b, char4 c);

char8 __ovld __cnfn select(char8 a, char8 b, char8 c);

uchar8 __ovld __cnfn select(uchar8 a, uchar8 b, char8 c);

char16 __ovld __cnfn select(char16 a, char16 b, char16 c);

uchar16 __ovld __cnfn select(uchar16 a, uchar16 b, char16 c);


short __ovld __cnfn select(short a, short b, short c);

ushort __ovld __cnfn select(ushort a, ushort b, short c);

short2 __ovld __cnfn select(short2 a, short2 b, short2 c);

ushort2 __ovld __cnfn select(ushort2 a, ushort2 b, short2 c);

short3 __ovld __cnfn select(short3 a, short3 b, short3 c);

ushort3 __ovld __cnfn select(ushort3 a, ushort3 b, short3 c);

short4 __ovld __cnfn select(short4 a, short4 b, short4 c);

ushort4 __ovld __cnfn select(ushort4 a, ushort4 b, short4 c);

short8 __ovld __cnfn select(short8 a, short8 b, short8 c);

ushort8 __ovld __cnfn select(ushort8 a, ushort8 b, short8 c);

short16 __ovld __cnfn select(short16 a, short16 b, short16 c);

ushort16 __ovld __cnfn select(ushort16 a, ushort16 b, short16 c);


int __ovld __cnfn select(int a, int b, int c);

uint __ovld __cnfn select(uint a, uint b, int c);

int2 __ovld __cnfn select(int2 a, int2 b, int2 c);

uint2 __ovld __cnfn select(uint2 a, uint2 b, int2 c);

int3 __ovld __cnfn select(int3 a, int3 b, int3 c);

uint3 __ovld __cnfn select(uint3 a, uint3 b, int3 c);

int4 __ovld __cnfn select(int4 a, int4 b, int4 c);

uint4 __ovld __cnfn select(uint4 a, uint4 b, int4 c);

int8 __ovld __cnfn select(int8 a, int8 b, int8 c);

uint8 __ovld __cnfn select(uint8 a, uint8 b, int8 c);

int16 __ovld __cnfn select(int16 a, int16 b, int16 c);

uint16 __ovld __cnfn select(uint16 a, uint16 b, int16 c);

float __ovld __cnfn select(float a, float b, int c);

float2 __ovld __cnfn select(float2 a, float2 b, int2 c);

float3 __ovld __cnfn select(float3 a, float3 b, int3 c);

float4 __ovld __cnfn select(float4 a, float4 b, int4 c);

float8 __ovld __cnfn select(float8 a, float8 b, int8 c);

float16 __ovld __cnfn select(float16 a, float16 b, int16 c);


long __ovld __cnfn select(long a, long b, long c);

ulong __ovld __cnfn select(ulong a, ulong b, long c);

long2 __ovld __cnfn select(long2 a, long2 b, long2 c);

ulong2 __ovld __cnfn select(ulong2 a, ulong2 b, long2 c);

long3 __ovld __cnfn select(long3 a, long3 b, long3 c);

ulong3 __ovld __cnfn select(ulong3 a, ulong3 b, long3 c);

long4 __ovld __cnfn select(long4 a, long4 b, long4 c);

ulong4 __ovld __cnfn select(ulong4 a, ulong4 b, long4 c);

long8 __ovld __cnfn select(long8 a, long8 b, long8 c);

ulong8 __ovld __cnfn select(ulong8 a, ulong8 b, long8 c);

long16 __ovld __cnfn select(long16 a, long16 b, long16 c);

ulong16 __ovld __cnfn select(ulong16 a, ulong16 b, long16 c);


char __ovld __cnfn select(char a, char b, uchar c);

uchar __ovld __cnfn select(uchar a, uchar b, uchar c);

char2 __ovld __cnfn select(char2 a, char2 b, uchar2 c);

uchar2 __ovld __cnfn select(uchar2 a, uchar2 b, uchar2 c);

char3 __ovld __cnfn select(char3 a, char3 b, uchar3 c);

uchar3 __ovld __cnfn select(uchar3 a, uchar3 b, uchar3 c);

char4 __ovld __cnfn select(char4 a, char4 b, uchar4 c);

uchar4 __ovld __cnfn select(uchar4 a, uchar4 b, uchar4 c);

char8 __ovld __cnfn select(char8 a, char8 b, uchar8 c);

uchar8 __ovld __cnfn select(uchar8 a, uchar8 b, uchar8 c);

char16 __ovld __cnfn select(char16 a, char16 b, uchar16 c);

uchar16 __ovld __cnfn select(uchar16 a, uchar16 b, uchar16 c);


short __ovld __cnfn select(short a, short b, ushort c);

ushort __ovld __cnfn select(ushort a, ushort b, ushort c);

short2 __ovld __cnfn select(short2 a, short2 b, ushort2 c);

ushort2 __ovld __cnfn select(ushort2 a, ushort2 b, ushort2 c);

short3 __ovld __cnfn select(short3 a, short3 b, ushort3 c);

ushort3 __ovld __cnfn select(ushort3 a, ushort3 b, ushort3 c);

short4 __ovld __cnfn select(short4 a, short4 b, ushort4 c);

ushort4 __ovld __cnfn select(ushort4 a, ushort4 b, ushort4 c);

short8 __ovld __cnfn select(short8 a, short8 b, ushort8 c);

ushort8 __ovld __cnfn select(ushort8 a, ushort8 b, ushort8 c);

short16 __ovld __cnfn select(short16 a, short16 b, ushort16 c);

ushort16 __ovld __cnfn select(ushort16 a, ushort16 b, ushort16 c);


int __ovld __cnfn select(int a, int b, uint c);

uint __ovld __cnfn select(uint a, uint b, uint c);

int2 __ovld __cnfn select(int2 a, int2 b, uint2 c);

uint2 __ovld __cnfn select(uint2 a, uint2 b, uint2 c);

int3 __ovld __cnfn select(int3 a, int3 b, uint3 c);

uint3 __ovld __cnfn select(uint3 a, uint3 b, uint3 c);

int4 __ovld __cnfn select(int4 a, int4 b, uint4 c);

uint4 __ovld __cnfn select(uint4 a, uint4 b, uint4 c);

int8 __ovld __cnfn select(int8 a, int8 b, uint8 c);

uint8 __ovld __cnfn select(uint8 a, uint8 b, uint8 c);

int16 __ovld __cnfn select(int16 a, int16 b, uint16 c);

uint16 __ovld __cnfn select(uint16 a, uint16 b, uint16 c);

float __ovld __cnfn select(float a, float b, uint c);

float2 __ovld __cnfn select(float2 a, float2 b, uint2 c);

float3 __ovld __cnfn select(float3 a, float3 b, uint3 c);

float4 __ovld __cnfn select(float4 a, float4 b, uint4 c);

float8 __ovld __cnfn select(float8 a, float8 b, uint8 c);

float16 __ovld __cnfn select(float16 a, float16 b, uint16 c);


long __ovld __cnfn select(long a, long b, ulong c);

ulong __ovld __cnfn select(ulong a, ulong b, ulong c);

long2 __ovld __cnfn select(long2 a, long2 b, ulong2 c);

ulong2 __ovld __cnfn select(ulong2 a, ulong2 b, ulong2 c);

long3 __ovld __cnfn select(long3 a, long3 b, ulong3 c);

ulong3 __ovld __cnfn select(ulong3 a, ulong3 b, ulong3 c);

long4 __ovld __cnfn select(long4 a, long4 b, ulong4 c);

ulong4 __ovld __cnfn select(ulong4 a, ulong4 b, ulong4 c);

long8 __ovld __cnfn select(long8 a, long8 b, ulong8 c);

ulong8 __ovld __cnfn select(ulong8 a, ulong8 b, ulong8 c);

long16 __ovld __cnfn select(long16 a, long16 b, ulong16 c);

ulong16 __ovld __cnfn select(ulong16 a, ulong16 b, ulong16 c);


#ifdef cl_khr_fp64

double __ovld __cnfn select(double a, double b, long c);

double2 __ovld __cnfn select(double2 a, double2 b, long2 c);

double3 __ovld __cnfn select(double3 a, double3 b, long3 c);

double4 __ovld __cnfn select(double4 a, double4 b, long4 c);

double8 __ovld __cnfn select(double8 a, double8 b, long8 c);

double16 __ovld __cnfn select(double16 a, double16 b, long16 c);

double __ovld __cnfn select(double a, double b, ulong c);

double2 __ovld __cnfn select(double2 a, double2 b, ulong2 c);

double3 __ovld __cnfn select(double3 a, double3 b, ulong3 c);

double4 __ovld __cnfn select(double4 a, double4 b, ulong4 c);

double8 __ovld __cnfn select(double8 a, double8 b, ulong8 c);

double16 __ovld __cnfn select(double16 a, double16 b, ulong16 c);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

half __ovld __cnfn select(half a, half b, short c);

half2 __ovld __cnfn select(half2 a, half2 b, short2 c);

half3 __ovld __cnfn select(half3 a, half3 b, short3 c);

half4 __ovld __cnfn select(half4 a, half4 b, short4 c);

half8 __ovld __cnfn select(half8 a, half8 b, short8 c);

half16 __ovld __cnfn select(half16 a, half16 b, short16 c);

half __ovld __cnfn select(half a, half b, ushort c);

half2 __ovld __cnfn select(half2 a, half2 b, ushort2 c);

half3 __ovld __cnfn select(half3 a, half3 b, ushort3 c);

half4 __ovld __cnfn select(half4 a, half4 b, ushort4 c);

half8 __ovld __cnfn select(half8 a, half8 b, ushort8 c);

half16 __ovld __cnfn select(half16 a, half16 b, ushort16 c);

#endif //cl_khr_fp16


// OpenCL v1.1 s6.11.7, v1.2 s6.12.7, v2.0 s6.13.7 - Vector Data Load and Store Functions

// OpenCL extensions v1.1 s9.6.6, v1.2 s9.5.6, v2.0 s9.4.6 - Vector Data Load and Store Functions for Half Type

char2 __ovld vload2(size_t offset, const __constant char *p);

uchar2 __ovld vload2(size_t offset, const __constant uchar *p);

short2 __ovld vload2(size_t offset, const __constant short *p);

ushort2 __ovld vload2(size_t offset, const __constant ushort *p);

int2 __ovld vload2(size_t offset, const __constant int *p);

uint2 __ovld vload2(size_t offset, const __constant uint *p);

long2 __ovld vload2(size_t offset, const __constant long *p);

ulong2 __ovld vload2(size_t offset, const __constant ulong *p);

float2 __ovld vload2(size_t offset, const __constant float *p);

char3 __ovld vload3(size_t offset, const __constant char *p);

uchar3 __ovld vload3(size_t offset, const __constant uchar *p);

short3 __ovld vload3(size_t offset, const __constant short *p);

ushort3 __ovld vload3(size_t offset, const __constant ushort *p);

int3 __ovld vload3(size_t offset, const __constant int *p);

uint3 __ovld vload3(size_t offset, const __constant uint *p);

long3 __ovld vload3(size_t offset, const __constant long *p);

ulong3 __ovld vload3(size_t offset, const __constant ulong *p);

float3 __ovld vload3(size_t offset, const __constant float *p);

char4 __ovld vload4(size_t offset, const __constant char *p);

uchar4 __ovld vload4(size_t offset, const __constant uchar *p);

short4 __ovld vload4(size_t offset, const __constant short *p);

ushort4 __ovld vload4(size_t offset, const __constant ushort *p);

int4 __ovld vload4(size_t offset, const __constant int *p);

uint4 __ovld vload4(size_t offset, const __constant uint *p);

long4 __ovld vload4(size_t offset, const __constant long *p);

ulong4 __ovld vload4(size_t offset, const __constant ulong *p);

float4 __ovld vload4(size_t offset, const __constant float *p);

char8 __ovld vload8(size_t offset, const __constant char *p);

uchar8 __ovld vload8(size_t offset, const __constant uchar *p);

short8 __ovld vload8(size_t offset, const __constant short *p);

ushort8 __ovld vload8(size_t offset, const __constant ushort *p);

int8 __ovld vload8(size_t offset, const __constant int *p);

uint8 __ovld vload8(size_t offset, const __constant uint *p);

long8 __ovld vload8(size_t offset, const __constant long *p);

ulong8 __ovld vload8(size_t offset, const __constant ulong *p);

float8 __ovld vload8(size_t offset, const __constant float *p);

char16 __ovld vload16(size_t offset, const __constant char *p);

uchar16 __ovld vload16(size_t offset, const __constant uchar *p);

short16 __ovld vload16(size_t offset, const __constant short *p);

ushort16 __ovld vload16(size_t offset, const __constant ushort *p);

int16 __ovld vload16(size_t offset, const __constant int *p);

uint16 __ovld vload16(size_t offset, const __constant uint *p);

long16 __ovld vload16(size_t offset, const __constant long *p);

ulong16 __ovld vload16(size_t offset, const __constant ulong *p);

float16 __ovld vload16(size_t offset, const __constant float *p);

#ifdef cl_khr_fp64

double2 __ovld vload2(size_t offset, const __constant double *p);

double3 __ovld vload3(size_t offset, const __constant double *p);

double4 __ovld vload4(size_t offset, const __constant double *p);

double8 __ovld vload8(size_t offset, const __constant double *p);

double16 __ovld vload16(size_t offset, const __constant double *p);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

half __ovld vload(size_t offset, const __constant half *p);

half2 __ovld vload2(size_t offset, const __constant half *p);

half3 __ovld vload3(size_t offset, const __constant half *p);

half4 __ovld vload4(size_t offset, const __constant half *p);

half8 __ovld vload8(size_t offset, const __constant half *p);

half16 __ovld vload16(size_t offset, const __constant half *p);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

char2 __ovld vload2(size_t offset, const char *p);

uchar2 __ovld vload2(size_t offset, const uchar *p);

short2 __ovld vload2(size_t offset, const short *p);

ushort2 __ovld vload2(size_t offset, const ushort *p);

int2 __ovld vload2(size_t offset, const int *p);

uint2 __ovld vload2(size_t offset, const uint *p);

long2 __ovld vload2(size_t offset, const long *p);

ulong2 __ovld vload2(size_t offset, const ulong *p);

float2 __ovld vload2(size_t offset, const float *p);

char3 __ovld vload3(size_t offset, const char *p);

uchar3 __ovld vload3(size_t offset, const uchar *p);

short3 __ovld vload3(size_t offset, const short *p);

ushort3 __ovld vload3(size_t offset, const ushort *p);

int3 __ovld vload3(size_t offset, const int *p);

uint3 __ovld vload3(size_t offset, const uint *p);

long3 __ovld vload3(size_t offset, const long *p);

ulong3 __ovld vload3(size_t offset, const ulong *p);

float3 __ovld vload3(size_t offset, const float *p);

char4 __ovld vload4(size_t offset, const char *p);

uchar4 __ovld vload4(size_t offset, const uchar *p);

short4 __ovld vload4(size_t offset, const short *p);

ushort4 __ovld vload4(size_t offset, const ushort *p);

int4 __ovld vload4(size_t offset, const int *p);

uint4 __ovld vload4(size_t offset, const uint *p);

long4 __ovld vload4(size_t offset, const long *p);

ulong4 __ovld vload4(size_t offset, const ulong *p);

float4 __ovld vload4(size_t offset, const float *p);

char8 __ovld vload8(size_t offset, const char *p);

uchar8 __ovld vload8(size_t offset, const uchar *p);

short8 __ovld vload8(size_t offset, const short *p);

ushort8 __ovld vload8(size_t offset, const ushort *p);

int8 __ovld vload8(size_t offset, const int *p);

uint8 __ovld vload8(size_t offset, const uint *p);

long8 __ovld vload8(size_t offset, const long *p);

ulong8 __ovld vload8(size_t offset, const ulong *p);

float8 __ovld vload8(size_t offset, const float *p);

char16 __ovld vload16(size_t offset, const char *p);

uchar16 __ovld vload16(size_t offset, const uchar *p);

short16 __ovld vload16(size_t offset, const short *p);

ushort16 __ovld vload16(size_t offset, const ushort *p);

int16 __ovld vload16(size_t offset, const int *p);

uint16 __ovld vload16(size_t offset, const uint *p);

long16 __ovld vload16(size_t offset, const long *p);

ulong16 __ovld vload16(size_t offset, const ulong *p);

float16 __ovld vload16(size_t offset, const float *p);


#ifdef cl_khr_fp64

double2 __ovld vload2(size_t offset, const double *p);

double3 __ovld vload3(size_t offset, const double *p);

double4 __ovld vload4(size_t offset, const double *p);

double8 __ovld vload8(size_t offset, const double *p);

double16 __ovld vload16(size_t offset, const double *p);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

half __ovld vload(size_t offset, const half *p);

half2 __ovld vload2(size_t offset, const half *p);

half3 __ovld vload3(size_t offset, const half *p);

half4 __ovld vload4(size_t offset, const half *p);

half8 __ovld vload8(size_t offset, const half *p);

half16 __ovld vload16(size_t offset, const half *p);

#endif //cl_khr_fp16

#else

char2 __ovld vload2(size_t offset, const __global char *p);

uchar2 __ovld vload2(size_t offset, const __global uchar *p);

short2 __ovld vload2(size_t offset, const __global short *p);

ushort2 __ovld vload2(size_t offset, const __global ushort *p);

int2 __ovld vload2(size_t offset, const __global int *p);

uint2 __ovld vload2(size_t offset, const __global uint *p);

long2 __ovld vload2(size_t offset, const __global long *p);

ulong2 __ovld vload2(size_t offset, const __global ulong *p);

float2 __ovld vload2(size_t offset, const __global float *p);

char3 __ovld vload3(size_t offset, const __global char *p);

uchar3 __ovld vload3(size_t offset, const __global uchar *p);

short3 __ovld vload3(size_t offset, const __global short *p);

ushort3 __ovld vload3(size_t offset, const __global ushort *p);

int3 __ovld vload3(size_t offset, const __global int *p);

uint3 __ovld vload3(size_t offset, const __global uint *p);

long3 __ovld vload3(size_t offset, const __global long *p);

ulong3 __ovld vload3(size_t offset, const __global ulong *p);

float3 __ovld vload3(size_t offset, const __global float *p);

char4 __ovld vload4(size_t offset, const __global char *p);

uchar4 __ovld vload4(size_t offset, const __global uchar *p);

short4 __ovld vload4(size_t offset, const __global short *p);

ushort4 __ovld vload4(size_t offset, const __global ushort *p);

int4 __ovld vload4(size_t offset, const __global int *p);

uint4 __ovld vload4(size_t offset, const __global uint *p);

long4 __ovld vload4(size_t offset, const __global long *p);

ulong4 __ovld vload4(size_t offset, const __global ulong *p);

float4 __ovld vload4(size_t offset, const __global float *p);

char8 __ovld vload8(size_t offset, const __global char *p);

uchar8 __ovld vload8(size_t offset, const __global uchar *p);

short8 __ovld vload8(size_t offset, const __global short *p);

ushort8 __ovld vload8(size_t offset, const __global ushort *p);

int8 __ovld vload8(size_t offset, const __global int *p);

uint8 __ovld vload8(size_t offset, const __global uint *p);

long8 __ovld vload8(size_t offset, const __global long *p);

ulong8 __ovld vload8(size_t offset, const __global ulong *p);

float8 __ovld vload8(size_t offset, const __global float *p);

char16 __ovld vload16(size_t offset, const __global char *p);

uchar16 __ovld vload16(size_t offset, const __global uchar *p);

short16 __ovld vload16(size_t offset, const __global short *p);

ushort16 __ovld vload16(size_t offset, const __global ushort *p);

int16 __ovld vload16(size_t offset, const __global int *p);

uint16 __ovld vload16(size_t offset, const __global uint *p);

long16 __ovld vload16(size_t offset, const __global long *p);

ulong16 __ovld vload16(size_t offset, const __global ulong *p);

float16 __ovld vload16(size_t offset, const __global float *p);

char2 __ovld vload2(size_t offset, const __local char *p);

uchar2 __ovld vload2(size_t offset, const __local uchar *p);

short2 __ovld vload2(size_t offset, const __local short *p);

ushort2 __ovld vload2(size_t offset, const __local ushort *p);

int2 __ovld vload2(size_t offset, const __local int *p);

uint2 __ovld vload2(size_t offset, const __local uint *p);

long2 __ovld vload2(size_t offset, const __local long *p);

ulong2 __ovld vload2(size_t offset, const __local ulong *p);

float2 __ovld vload2(size_t offset, const __local float *p);

char3 __ovld vload3(size_t offset, const __local char *p);

uchar3 __ovld vload3(size_t offset, const __local uchar *p);

short3 __ovld vload3(size_t offset, const __local short *p);

ushort3 __ovld vload3(size_t offset, const __local ushort *p);

int3 __ovld vload3(size_t offset, const __local int *p);

uint3 __ovld vload3(size_t offset, const __local uint *p);

long3 __ovld vload3(size_t offset, const __local long *p);

ulong3 __ovld vload3(size_t offset, const __local ulong *p);

float3 __ovld vload3(size_t offset, const __local float *p);

char4 __ovld vload4(size_t offset, const __local char *p);

uchar4 __ovld vload4(size_t offset, const __local uchar *p);

short4 __ovld vload4(size_t offset, const __local short *p);

ushort4 __ovld vload4(size_t offset, const __local ushort *p);

int4 __ovld vload4(size_t offset, const __local int *p);

uint4 __ovld vload4(size_t offset, const __local uint *p);

long4 __ovld vload4(size_t offset, const __local long *p);

ulong4 __ovld vload4(size_t offset, const __local ulong *p);

float4 __ovld vload4(size_t offset, const __local float *p);

char8 __ovld vload8(size_t offset, const __local char *p);

uchar8 __ovld vload8(size_t offset, const __local uchar *p);

short8 __ovld vload8(size_t offset, const __local short *p);

ushort8 __ovld vload8(size_t offset, const __local ushort *p);

int8 __ovld vload8(size_t offset, const __local int *p);

uint8 __ovld vload8(size_t offset, const __local uint *p);

long8 __ovld vload8(size_t offset, const __local long *p);

ulong8 __ovld vload8(size_t offset, const __local ulong *p);

float8 __ovld vload8(size_t offset, const __local float *p);

char16 __ovld vload16(size_t offset, const __local char *p);

uchar16 __ovld vload16(size_t offset, const __local uchar *p);

short16 __ovld vload16(size_t offset, const __local short *p);

ushort16 __ovld vload16(size_t offset, const __local ushort *p);

int16 __ovld vload16(size_t offset, const __local int *p);

uint16 __ovld vload16(size_t offset, const __local uint *p);

long16 __ovld vload16(size_t offset, const __local long *p);

ulong16 __ovld vload16(size_t offset, const __local ulong *p);

float16 __ovld vload16(size_t offset, const __local float *p);

char2 __ovld vload2(size_t offset, const __private char *p);

uchar2 __ovld vload2(size_t offset, const __private uchar *p);

short2 __ovld vload2(size_t offset, const __private short *p);

ushort2 __ovld vload2(size_t offset, const __private ushort *p);

int2 __ovld vload2(size_t offset, const __private int *p);

uint2 __ovld vload2(size_t offset, const __private uint *p);

long2 __ovld vload2(size_t offset, const __private long *p);

ulong2 __ovld vload2(size_t offset, const __private ulong *p);

float2 __ovld vload2(size_t offset, const __private float *p);

char3 __ovld vload3(size_t offset, const __private char *p);

uchar3 __ovld vload3(size_t offset, const __private uchar *p);

short3 __ovld vload3(size_t offset, const __private short *p);

ushort3 __ovld vload3(size_t offset, const __private ushort *p);

int3 __ovld vload3(size_t offset, const __private int *p);

uint3 __ovld vload3(size_t offset, const __private uint *p);

long3 __ovld vload3(size_t offset, const __private long *p);

ulong3 __ovld vload3(size_t offset, const __private ulong *p);

float3 __ovld vload3(size_t offset, const __private float *p);

char4 __ovld vload4(size_t offset, const __private char *p);

uchar4 __ovld vload4(size_t offset, const __private uchar *p);

short4 __ovld vload4(size_t offset, const __private short *p);

ushort4 __ovld vload4(size_t offset, const __private ushort *p);

int4 __ovld vload4(size_t offset, const __private int *p);

uint4 __ovld vload4(size_t offset, const __private uint *p);

long4 __ovld vload4(size_t offset, const __private long *p);

ulong4 __ovld vload4(size_t offset, const __private ulong *p);

float4 __ovld vload4(size_t offset, const __private float *p);

char8 __ovld vload8(size_t offset, const __private char *p);

uchar8 __ovld vload8(size_t offset, const __private uchar *p);

short8 __ovld vload8(size_t offset, const __private short *p);

ushort8 __ovld vload8(size_t offset, const __private ushort *p);

int8 __ovld vload8(size_t offset, const __private int *p);

uint8 __ovld vload8(size_t offset, const __private uint *p);

long8 __ovld vload8(size_t offset, const __private long *p);

ulong8 __ovld vload8(size_t offset, const __private ulong *p);

float8 __ovld vload8(size_t offset, const __private float *p);

char16 __ovld vload16(size_t offset, const __private char *p);

uchar16 __ovld vload16(size_t offset, const __private uchar *p);

short16 __ovld vload16(size_t offset, const __private short *p);

ushort16 __ovld vload16(size_t offset, const __private ushort *p);

int16 __ovld vload16(size_t offset, const __private int *p);

uint16 __ovld vload16(size_t offset, const __private uint *p);

long16 __ovld vload16(size_t offset, const __private long *p);

ulong16 __ovld vload16(size_t offset, const __private ulong *p);

float16 __ovld vload16(size_t offset, const __private float *p);


#ifdef cl_khr_fp64

double2 __ovld vload2(size_t offset, const __global double *p);

double3 __ovld vload3(size_t offset, const __global double *p);

double4 __ovld vload4(size_t offset, const __global double *p);

double8 __ovld vload8(size_t offset, const __global double *p);

double16 __ovld vload16(size_t offset, const __global double *p);

double2 __ovld vload2(size_t offset, const __local double *p);

double3 __ovld vload3(size_t offset, const __local double *p);

double4 __ovld vload4(size_t offset, const __local double *p);

double8 __ovld vload8(size_t offset, const __local double *p);

double16 __ovld vload16(size_t offset, const __local double *p);

double2 __ovld vload2(size_t offset, const __private double *p);

double3 __ovld vload3(size_t offset, const __private double *p);

double4 __ovld vload4(size_t offset, const __private double *p);

double8 __ovld vload8(size_t offset, const __private double *p);

double16 __ovld vload16(size_t offset, const __private double *p);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

half __ovld vload(size_t offset, const __global half *p);

half2 __ovld vload2(size_t offset, const __global half *p);

half3 __ovld vload3(size_t offset, const __global half *p);

half4 __ovld vload4(size_t offset, const __global half *p);

half8 __ovld vload8(size_t offset, const __global half *p);

half16 __ovld vload16(size_t offset, const __global half *p);

half __ovld vload(size_t offset, const __local half *p);

half2 __ovld vload2(size_t offset, const __local half *p);

half3 __ovld vload3(size_t offset, const __local half *p);

half4 __ovld vload4(size_t offset, const __local half *p);

half8 __ovld vload8(size_t offset, const __local half *p);

half16 __ovld vload16(size_t offset, const __local half *p);

half __ovld vload(size_t offset, const __private half *p);

half2 __ovld vload2(size_t offset, const __private half *p);

half3 __ovld vload3(size_t offset, const __private half *p);

half4 __ovld vload4(size_t offset, const __private half *p);

half8 __ovld vload8(size_t offset, const __private half *p);

half16 __ovld vload16(size_t offset, const __private half *p);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __ovld vstore2(char2 data, size_t offset, char *p);

void __ovld vstore2(uchar2 data, size_t offset, uchar *p);

void __ovld vstore2(short2 data, size_t offset, short *p);

void __ovld vstore2(ushort2 data, size_t offset, ushort *p);

void __ovld vstore2(int2 data, size_t offset, int *p);

void __ovld vstore2(uint2 data, size_t offset, uint *p);

void __ovld vstore2(long2 data, size_t offset, long *p);

void __ovld vstore2(ulong2 data, size_t offset, ulong *p);

void __ovld vstore2(float2 data, size_t offset, float *p);

void __ovld vstore3(char3 data, size_t offset, char *p);

void __ovld vstore3(uchar3 data, size_t offset, uchar *p);

void __ovld vstore3(short3 data, size_t offset, short *p);

void __ovld vstore3(ushort3 data, size_t offset, ushort *p);

void __ovld vstore3(int3 data, size_t offset, int *p);

void __ovld vstore3(uint3 data, size_t offset, uint *p);

void __ovld vstore3(long3 data, size_t offset, long *p);

void __ovld vstore3(ulong3 data, size_t offset, ulong *p);

void __ovld vstore3(float3 data, size_t offset, float *p);

void __ovld vstore4(char4 data, size_t offset, char *p);

void __ovld vstore4(uchar4 data, size_t offset, uchar *p);

void __ovld vstore4(short4 data, size_t offset, short *p);

void __ovld vstore4(ushort4 data, size_t offset, ushort *p);

void __ovld vstore4(int4 data, size_t offset, int *p);

void __ovld vstore4(uint4 data, size_t offset, uint *p);

void __ovld vstore4(long4 data, size_t offset, long *p);

void __ovld vstore4(ulong4 data, size_t offset, ulong *p);

void __ovld vstore4(float4 data, size_t offset, float *p);

void __ovld vstore8(char8 data, size_t offset, char *p);

void __ovld vstore8(uchar8 data, size_t offset, uchar *p);

void __ovld vstore8(short8 data, size_t offset, short *p);

void __ovld vstore8(ushort8 data, size_t offset, ushort *p);

void __ovld vstore8(int8 data, size_t offset, int *p);

void __ovld vstore8(uint8 data, size_t offset, uint *p);

void __ovld vstore8(long8 data, size_t offset, long *p);

void __ovld vstore8(ulong8 data, size_t offset, ulong *p);

void __ovld vstore8(float8 data, size_t offset, float *p);

void __ovld vstore16(char16 data, size_t offset, char *p);

void __ovld vstore16(uchar16 data, size_t offset, uchar *p);

void __ovld vstore16(short16 data, size_t offset, short *p);

void __ovld vstore16(ushort16 data, size_t offset, ushort *p);

void __ovld vstore16(int16 data, size_t offset, int *p);

void __ovld vstore16(uint16 data, size_t offset, uint *p);

void __ovld vstore16(long16 data, size_t offset, long *p);

void __ovld vstore16(ulong16 data, size_t offset, ulong *p);

void __ovld vstore16(float16 data, size_t offset, float *p);

#ifdef cl_khr_fp64

void __ovld vstore2(double2 data, size_t offset, double *p);

void __ovld vstore3(double3 data, size_t offset, double *p);

void __ovld vstore4(double4 data, size_t offset, double *p);

void __ovld vstore8(double8 data, size_t offset, double *p);

void __ovld vstore16(double16 data, size_t offset, double *p);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

void __ovld vstore(half data, size_t offset, half *p);

void __ovld vstore2(half2 data, size_t offset, half *p);

void __ovld vstore3(half3 data, size_t offset, half *p);

void __ovld vstore4(half4 data, size_t offset, half *p);

void __ovld vstore8(half8 data, size_t offset, half *p);

void __ovld vstore16(half16 data, size_t offset, half *p);

#endif //cl_khr_fp16

#else

void __ovld vstore2(char2 data, size_t offset, __global char *p);

void __ovld vstore2(uchar2 data, size_t offset, __global uchar *p);

void __ovld vstore2(short2 data, size_t offset, __global short *p);

void __ovld vstore2(ushort2 data, size_t offset, __global ushort *p);

void __ovld vstore2(int2 data, size_t offset, __global int *p);

void __ovld vstore2(uint2 data, size_t offset, __global uint *p);

void __ovld vstore2(long2 data, size_t offset, __global long *p);

void __ovld vstore2(ulong2 data, size_t offset, __global ulong *p);

void __ovld vstore2(float2 data, size_t offset, __global float *p);

void __ovld vstore3(char3 data, size_t offset, __global char *p);

void __ovld vstore3(uchar3 data, size_t offset, __global uchar *p);

void __ovld vstore3(short3 data, size_t offset, __global short *p);

void __ovld vstore3(ushort3 data, size_t offset, __global ushort *p);

void __ovld vstore3(int3 data, size_t offset, __global int *p);

void __ovld vstore3(uint3 data, size_t offset, __global uint *p);

void __ovld vstore3(long3 data, size_t offset, __global long *p);

void __ovld vstore3(ulong3 data, size_t offset, __global ulong *p);

void __ovld vstore3(float3 data, size_t offset, __global float *p);

void __ovld vstore4(char4 data, size_t offset, __global char *p);

void __ovld vstore4(uchar4 data, size_t offset, __global uchar *p);

void __ovld vstore4(short4 data, size_t offset, __global short *p);

void __ovld vstore4(ushort4 data, size_t offset, __global ushort *p);

void __ovld vstore4(int4 data, size_t offset, __global int *p);

void __ovld vstore4(uint4 data, size_t offset, __global uint *p);

void __ovld vstore4(long4 data, size_t offset, __global long *p);

void __ovld vstore4(ulong4 data, size_t offset, __global ulong *p);

void __ovld vstore4(float4 data, size_t offset, __global float *p);

void __ovld vstore8(char8 data, size_t offset, __global char *p);

void __ovld vstore8(uchar8 data, size_t offset, __global uchar *p);

void __ovld vstore8(short8 data, size_t offset, __global short *p);

void __ovld vstore8(ushort8 data, size_t offset, __global ushort *p);

void __ovld vstore8(int8 data, size_t offset, __global int *p);

void __ovld vstore8(uint8 data, size_t offset, __global uint *p);

void __ovld vstore8(long8 data, size_t offset, __global long *p);

void __ovld vstore8(ulong8 data, size_t offset, __global ulong *p);

void __ovld vstore8(float8 data, size_t offset, __global float *p);

void __ovld vstore16(char16 data, size_t offset, __global char *p);

void __ovld vstore16(uchar16 data, size_t offset, __global uchar *p);

void __ovld vstore16(short16 data, size_t offset, __global short *p);

void __ovld vstore16(ushort16 data, size_t offset, __global ushort *p);

void __ovld vstore16(int16 data, size_t offset, __global int *p);

void __ovld vstore16(uint16 data, size_t offset, __global uint *p);

void __ovld vstore16(long16 data, size_t offset, __global long *p);

void __ovld vstore16(ulong16 data, size_t offset, __global ulong *p);

void __ovld vstore16(float16 data, size_t offset, __global float *p);

void __ovld vstore2(char2 data, size_t offset, __local char *p);

void __ovld vstore2(uchar2 data, size_t offset, __local uchar *p);

void __ovld vstore2(short2 data, size_t offset, __local short *p);

void __ovld vstore2(ushort2 data, size_t offset, __local ushort *p);

void __ovld vstore2(int2 data, size_t offset, __local int *p);

void __ovld vstore2(uint2 data, size_t offset, __local uint *p);

void __ovld vstore2(long2 data, size_t offset, __local long *p);

void __ovld vstore2(ulong2 data, size_t offset, __local ulong *p);

void __ovld vstore2(float2 data, size_t offset, __local float *p);

void __ovld vstore3(char3 data, size_t offset, __local char *p);

void __ovld vstore3(uchar3 data, size_t offset, __local uchar *p);

void __ovld vstore3(short3 data, size_t offset, __local short *p);

void __ovld vstore3(ushort3 data, size_t offset, __local ushort *p);

void __ovld vstore3(int3 data, size_t offset, __local int *p);

void __ovld vstore3(uint3 data, size_t offset, __local uint *p);

void __ovld vstore3(long3 data, size_t offset, __local long *p);

void __ovld vstore3(ulong3 data, size_t offset, __local ulong *p);

void __ovld vstore3(float3 data, size_t offset, __local float *p);

void __ovld vstore4(char4 data, size_t offset, __local char *p);

void __ovld vstore4(uchar4 data, size_t offset, __local uchar *p);

void __ovld vstore4(short4 data, size_t offset, __local short *p);

void __ovld vstore4(ushort4 data, size_t offset, __local ushort *p);

void __ovld vstore4(int4 data, size_t offset, __local int *p);

void __ovld vstore4(uint4 data, size_t offset, __local uint *p);

void __ovld vstore4(long4 data, size_t offset, __local long *p);

void __ovld vstore4(ulong4 data, size_t offset, __local ulong *p);

void __ovld vstore4(float4 data, size_t offset, __local float *p);

void __ovld vstore8(char8 data, size_t offset, __local char *p);

void __ovld vstore8(uchar8 data, size_t offset, __local uchar *p);

void __ovld vstore8(short8 data, size_t offset, __local short *p);

void __ovld vstore8(ushort8 data, size_t offset, __local ushort *p);

void __ovld vstore8(int8 data, size_t offset, __local int *p);

void __ovld vstore8(uint8 data, size_t offset, __local uint *p);

void __ovld vstore8(long8 data, size_t offset, __local long *p);

void __ovld vstore8(ulong8 data, size_t offset, __local ulong *p);

void __ovld vstore8(float8 data, size_t offset, __local float *p);

void __ovld vstore16(char16 data, size_t offset, __local char *p);

void __ovld vstore16(uchar16 data, size_t offset, __local uchar *p);

void __ovld vstore16(short16 data, size_t offset, __local short *p);

void __ovld vstore16(ushort16 data, size_t offset, __local ushort *p);

void __ovld vstore16(int16 data, size_t offset, __local int *p);

void __ovld vstore16(uint16 data, size_t offset, __local uint *p);

void __ovld vstore16(long16 data, size_t offset, __local long *p);

void __ovld vstore16(ulong16 data, size_t offset, __local ulong *p);

void __ovld vstore16(float16 data, size_t offset, __local float *p);

void __ovld vstore2(char2 data, size_t offset, __private char *p);

void __ovld vstore2(uchar2 data, size_t offset, __private uchar *p);

void __ovld vstore2(short2 data, size_t offset, __private short *p);

void __ovld vstore2(ushort2 data, size_t offset, __private ushort *p);

void __ovld vstore2(int2 data, size_t offset, __private int *p);

void __ovld vstore2(uint2 data, size_t offset, __private uint *p);

void __ovld vstore2(long2 data, size_t offset, __private long *p);

void __ovld vstore2(ulong2 data, size_t offset, __private ulong *p);

void __ovld vstore2(float2 data, size_t offset, __private float *p);

void __ovld vstore3(char3 data, size_t offset, __private char *p);

void __ovld vstore3(uchar3 data, size_t offset, __private uchar *p);

void __ovld vstore3(short3 data, size_t offset, __private short *p);

void __ovld vstore3(ushort3 data, size_t offset, __private ushort *p);

void __ovld vstore3(int3 data, size_t offset, __private int *p);

void __ovld vstore3(uint3 data, size_t offset, __private uint *p);

void __ovld vstore3(long3 data, size_t offset, __private long *p);

void __ovld vstore3(ulong3 data, size_t offset, __private ulong *p);

void __ovld vstore3(float3 data, size_t offset, __private float *p);

void __ovld vstore4(char4 data, size_t offset, __private char *p);

void __ovld vstore4(uchar4 data, size_t offset, __private uchar *p);

void __ovld vstore4(short4 data, size_t offset, __private short *p);

void __ovld vstore4(ushort4 data, size_t offset, __private ushort *p);

void __ovld vstore4(int4 data, size_t offset, __private int *p);

void __ovld vstore4(uint4 data, size_t offset, __private uint *p);

void __ovld vstore4(long4 data, size_t offset, __private long *p);

void __ovld vstore4(ulong4 data, size_t offset, __private ulong *p);

void __ovld vstore4(float4 data, size_t offset, __private float *p);

void __ovld vstore8(char8 data, size_t offset, __private char *p);

void __ovld vstore8(uchar8 data, size_t offset, __private uchar *p);

void __ovld vstore8(short8 data, size_t offset, __private short *p);

void __ovld vstore8(ushort8 data, size_t offset, __private ushort *p);

void __ovld vstore8(int8 data, size_t offset, __private int *p);

void __ovld vstore8(uint8 data, size_t offset, __private uint *p);

void __ovld vstore8(long8 data, size_t offset, __private long *p);

void __ovld vstore8(ulong8 data, size_t offset, __private ulong *p);

void __ovld vstore8(float8 data, size_t offset, __private float *p);

void __ovld vstore16(char16 data, size_t offset, __private char *p);

void __ovld vstore16(uchar16 data, size_t offset, __private uchar *p);

void __ovld vstore16(short16 data, size_t offset, __private short *p);

void __ovld vstore16(ushort16 data, size_t offset, __private ushort *p);

void __ovld vstore16(int16 data, size_t offset, __private int *p);

void __ovld vstore16(uint16 data, size_t offset, __private uint *p);

void __ovld vstore16(long16 data, size_t offset, __private long *p);

void __ovld vstore16(ulong16 data, size_t offset, __private ulong *p);

void __ovld vstore16(float16 data, size_t offset, __private float *p);

#ifdef cl_khr_fp64

void __ovld vstore2(double2 data, size_t offset, __global double *p);

void __ovld vstore3(double3 data, size_t offset, __global double *p);

void __ovld vstore4(double4 data, size_t offset, __global double *p);

void __ovld vstore8(double8 data, size_t offset, __global double *p);

void __ovld vstore16(double16 data, size_t offset, __global double *p);

void __ovld vstore2(double2 data, size_t offset, __local double *p);

void __ovld vstore3(double3 data, size_t offset, __local double *p);

void __ovld vstore4(double4 data, size_t offset, __local double *p);

void __ovld vstore8(double8 data, size_t offset, __local double *p);

void __ovld vstore16(double16 data, size_t offset, __local double *p);

void __ovld vstore2(double2 data, size_t offset, __private double *p);

void __ovld vstore3(double3 data, size_t offset, __private double *p);

void __ovld vstore4(double4 data, size_t offset, __private double *p);

void __ovld vstore8(double8 data, size_t offset, __private double *p);

void __ovld vstore16(double16 data, size_t offset, __private double *p);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

void __ovld vstore(half data, size_t offset, __global half *p);

void __ovld vstore2(half2 data, size_t offset, __global half *p);

void __ovld vstore3(half3 data, size_t offset, __global half *p);

void __ovld vstore4(half4 data, size_t offset, __global half *p);

void __ovld vstore8(half8 data, size_t offset, __global half *p);

void __ovld vstore16(half16 data, size_t offset, __global half *p);

void __ovld vstore(half data, size_t offset, __local half *p);

void __ovld vstore2(half2 data, size_t offset, __local half *p);

void __ovld vstore3(half3 data, size_t offset, __local half *p);

void __ovld vstore4(half4 data, size_t offset, __local half *p);

void __ovld vstore8(half8 data, size_t offset, __local half *p);

void __ovld vstore16(half16 data, size_t offset, __local half *p);

void __ovld vstore(half data, size_t offset, __private half *p);

void __ovld vstore2(half2 data, size_t offset, __private half *p);

void __ovld vstore3(half3 data, size_t offset, __private half *p);

void __ovld vstore4(half4 data, size_t offset, __private half *p);

void __ovld vstore8(half8 data, size_t offset, __private half *p);

void __ovld vstore16(half16 data, size_t offset, __private half *p);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float __ovld vload_half(size_t offset, const __constant half *p);

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld vload_half(size_t offset, const half *p);

#else

float __ovld vload_half(size_t offset, const __global half *p);

float __ovld vload_half(size_t offset, const __local half *p);

float __ovld vload_half(size_t offset, const __private half *p);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float2 __ovld vload_half2(size_t offset, const __constant half *p);

float3 __ovld vload_half3(size_t offset, const __constant half *p);

float4 __ovld vload_half4(size_t offset, const __constant half *p);

float8 __ovld vload_half8(size_t offset, const __constant half *p);

float16 __ovld vload_half16(size_t offset, const __constant half *p);

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float2 __ovld vload_half2(size_t offset, const half *p);

float3 __ovld vload_half3(size_t offset, const half *p);

float4 __ovld vload_half4(size_t offset, const half *p);

float8 __ovld vload_half8(size_t offset, const half *p);

float16 __ovld vload_half16(size_t offset, const half *p);

#else

float2 __ovld vload_half2(size_t offset, const __global half *p);

float3 __ovld vload_half3(size_t offset, const __global half *p);

float4 __ovld vload_half4(size_t offset, const __global half *p);

float8 __ovld vload_half8(size_t offset, const __global half *p);

float16 __ovld vload_half16(size_t offset, const __global half *p);

float2 __ovld vload_half2(size_t offset, const __local half *p);

float3 __ovld vload_half3(size_t offset, const __local half *p);

float4 __ovld vload_half4(size_t offset, const __local half *p);

float8 __ovld vload_half8(size_t offset, const __local half *p);

float16 __ovld vload_half16(size_t offset, const __local half *p);

float2 __ovld vload_half2(size_t offset, const __private half *p);

float3 __ovld vload_half3(size_t offset, const __private half *p);

float4 __ovld vload_half4(size_t offset, const __private half *p);

float8 __ovld vload_half8(size_t offset, const __private half *p);

float16 __ovld vload_half16(size_t offset, const __private half *p);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __ovld vstore_half(float data, size_t offset, half *p);

void __ovld vstore_half_rte(float data, size_t offset, half *p);

void __ovld vstore_half_rtz(float data, size_t offset, half *p);

void __ovld vstore_half_rtp(float data, size_t offset, half *p);

void __ovld vstore_half_rtn(float data, size_t offset, half *p);

#ifdef cl_khr_fp64

void __ovld vstore_half(double data, size_t offset, half *p);

void __ovld vstore_half_rte(double data, size_t offset, half *p);

void __ovld vstore_half_rtz(double data, size_t offset, half *p);

void __ovld vstore_half_rtp(double data, size_t offset, half *p);

void __ovld vstore_half_rtn(double data, size_t offset, half *p);

#endif //cl_khr_fp64

#else

void __ovld vstore_half(float data, size_t offset, __global half *p);

void __ovld vstore_half_rte(float data, size_t offset, __global half *p);

void __ovld vstore_half_rtz(float data, size_t offset, __global half *p);

void __ovld vstore_half_rtp(float data, size_t offset, __global half *p);

void __ovld vstore_half_rtn(float data, size_t offset, __global half *p);

void __ovld vstore_half(float data, size_t offset, __local half *p);

void __ovld vstore_half_rte(float data, size_t offset, __local half *p);

void __ovld vstore_half_rtz(float data, size_t offset, __local half *p);

void __ovld vstore_half_rtp(float data, size_t offset, __local half *p);

void __ovld vstore_half_rtn(float data, size_t offset, __local half *p);

void __ovld vstore_half(float data, size_t offset, __private half *p);

void __ovld vstore_half_rte(float data, size_t offset, __private half *p);

void __ovld vstore_half_rtz(float data, size_t offset, __private half *p);

void __ovld vstore_half_rtp(float data, size_t offset, __private half *p);

void __ovld vstore_half_rtn(float data, size_t offset, __private half *p);

#ifdef cl_khr_fp64

void __ovld vstore_half(double data, size_t offset, __global half *p);

void __ovld vstore_half_rte(double data, size_t offset, __global half *p);

void __ovld vstore_half_rtz(double data, size_t offset, __global half *p);

void __ovld vstore_half_rtp(double data, size_t offset, __global half *p);

void __ovld vstore_half_rtn(double data, size_t offset, __global half *p);

void __ovld vstore_half(double data, size_t offset, __local half *p);

void __ovld vstore_half_rte(double data, size_t offset, __local half *p);

void __ovld vstore_half_rtz(double data, size_t offset, __local half *p);

void __ovld vstore_half_rtp(double data, size_t offset, __local half *p);

void __ovld vstore_half_rtn(double data, size_t offset, __local half *p);

void __ovld vstore_half(double data, size_t offset, __private half *p);

void __ovld vstore_half_rte(double data, size_t offset, __private half *p);

void __ovld vstore_half_rtz(double data, size_t offset, __private half *p);

void __ovld vstore_half_rtp(double data, size_t offset, __private half *p);

void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);

#endif //cl_khr_fp64

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __ovld vstore_half2(float2 data, size_t offset, half *p);

void __ovld vstore_half3(float3 data, size_t offset, half *p);

void __ovld vstore_half4(float4 data, size_t offset, half *p);

void __ovld vstore_half8(float8 data, size_t offset, half *p);

void __ovld vstore_half16(float16 data, size_t offset, half *p);

void __ovld vstore_half2_rte(float2 data, size_t offset, half *p);

void __ovld vstore_half3_rte(float3 data, size_t offset, half *p);

void __ovld vstore_half4_rte(float4 data, size_t offset, half *p);

void __ovld vstore_half8_rte(float8 data, size_t offset, half *p);

void __ovld vstore_half16_rte(float16 data, size_t offset, half *p);

void __ovld vstore_half2_rtz(float2 data, size_t offset, half *p);

void __ovld vstore_half3_rtz(float3 data, size_t offset, half *p);

void __ovld vstore_half4_rtz(float4 data, size_t offset, half *p);

void __ovld vstore_half8_rtz(float8 data, size_t offset, half *p);

void __ovld vstore_half16_rtz(float16 data, size_t offset, half *p);

void __ovld vstore_half2_rtp(float2 data, size_t offset, half *p);

void __ovld vstore_half3_rtp(float3 data, size_t offset, half *p);

void __ovld vstore_half4_rtp(float4 data, size_t offset, half *p);

void __ovld vstore_half8_rtp(float8 data, size_t offset, half *p);

void __ovld vstore_half16_rtp(float16 data, size_t offset, half *p);

void __ovld vstore_half2_rtn(float2 data, size_t offset, half *p);

void __ovld vstore_half3_rtn(float3 data, size_t offset, half *p);

void __ovld vstore_half4_rtn(float4 data, size_t offset, half *p);

void __ovld vstore_half8_rtn(float8 data, size_t offset, half *p);

void __ovld vstore_half16_rtn(float16 data, size_t offset, half *p);

#ifdef cl_khr_fp64

void __ovld vstore_half2(double2 data, size_t offset, half *p);

void __ovld vstore_half3(double3 data, size_t offset, half *p);

void __ovld vstore_half4(double4 data, size_t offset, half *p);

void __ovld vstore_half8(double8 data, size_t offset, half *p);

void __ovld vstore_half16(double16 data, size_t offset, half *p);

void __ovld vstore_half2_rte(double2 data, size_t offset, half *p);

void __ovld vstore_half3_rte(double3 data, size_t offset, half *p);

void __ovld vstore_half4_rte(double4 data, size_t offset, half *p);

void __ovld vstore_half8_rte(double8 data, size_t offset, half *p);

void __ovld vstore_half16_rte(double16 data, size_t offset, half *p);

void __ovld vstore_half2_rtz(double2 data, size_t offset, half *p);

void __ovld vstore_half3_rtz(double3 data, size_t offset, half *p);

void __ovld vstore_half4_rtz(double4 data, size_t offset, half *p);

void __ovld vstore_half8_rtz(double8 data, size_t offset, half *p);

void __ovld vstore_half16_rtz(double16 data, size_t offset, half *p);

void __ovld vstore_half2_rtp(double2 data, size_t offset, half *p);

void __ovld vstore_half3_rtp(double3 data, size_t offset, half *p);

void __ovld vstore_half4_rtp(double4 data, size_t offset, half *p);

void __ovld vstore_half8_rtp(double8 data, size_t offset, half *p);

void __ovld vstore_half16_rtp(double16 data, size_t offset, half *p);

void __ovld vstore_half2_rtn(double2 data, size_t offset, half *p);

void __ovld vstore_half3_rtn(double3 data, size_t offset, half *p);

void __ovld vstore_half4_rtn(double4 data, size_t offset, half *p);

void __ovld vstore_half8_rtn(double8 data, size_t offset, half *p);

void __ovld vstore_half16_rtn(double16 data, size_t offset, half *p);

#endif //cl_khr_fp64

#else

void __ovld vstore_half2(float2 data, size_t offset, __global half *p);

void __ovld vstore_half3(float3 data, size_t offset, __global half *p);

void __ovld vstore_half4(float4 data, size_t offset, __global half *p);

void __ovld vstore_half8(float8 data, size_t offset, __global half *p);

void __ovld vstore_half16(float16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rte(float2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rte(float3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rte(float4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rte(float8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rte(float16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rtz(float2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rtz(float3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rtz(float4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rtz(float8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rtz(float16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rtp(float2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rtp(float3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rtp(float4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rtp(float8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rtp(float16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rtn(float2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rtn(float3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rtn(float4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rtn(float8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rtn(float16 data, size_t offset, __global half *p);

void __ovld vstore_half2(float2 data, size_t offset, __local half *p);

void __ovld vstore_half3(float3 data, size_t offset, __local half *p);

void __ovld vstore_half4(float4 data, size_t offset, __local half *p);

void __ovld vstore_half8(float8 data, size_t offset, __local half *p);

void __ovld vstore_half16(float16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rte(float2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rte(float3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rte(float4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rte(float8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rte(float16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rtz(float2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rtz(float3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rtz(float4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rtz(float8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rtz(float16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rtp(float2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rtp(float3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rtp(float4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rtp(float8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rtp(float16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rtn(float2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rtn(float3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rtn(float4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rtn(float8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rtn(float16 data, size_t offset, __local half *p);

void __ovld vstore_half2(float2 data, size_t offset, __private half *p);

void __ovld vstore_half3(float3 data, size_t offset, __private half *p);

void __ovld vstore_half4(float4 data, size_t offset, __private half *p);

void __ovld vstore_half8(float8 data, size_t offset, __private half *p);

void __ovld vstore_half16(float16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rte(float2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rte(float3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rte(float4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rte(float8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rte(float16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rtz(float2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rtz(float3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rtz(float4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rtz(float8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rtz(float16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rtp(float2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rtp(float3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rtp(float4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rtp(float8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rtp(float16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rtn(float2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rtn(float3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rtn(float4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rtn(float8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rtn(float16 data, size_t offset, __private half *p);

#ifdef cl_khr_fp64

void __ovld vstore_half2(double2 data, size_t offset, __global half *p);

void __ovld vstore_half3(double3 data, size_t offset, __global half *p);

void __ovld vstore_half4(double4 data, size_t offset, __global half *p);

void __ovld vstore_half8(double8 data, size_t offset, __global half *p);

void __ovld vstore_half16(double16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rte(double2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rte(double3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rte(double4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rte(double8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rte(double16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rtz(double2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rtz(double3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rtz(double4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rtz(double8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rtz(double16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rtp(double2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rtp(double3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rtp(double4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rtp(double8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rtp(double16 data, size_t offset, __global half *p);

void __ovld vstore_half2_rtn(double2 data, size_t offset, __global half *p);

void __ovld vstore_half3_rtn(double3 data, size_t offset, __global half *p);

void __ovld vstore_half4_rtn(double4 data, size_t offset, __global half *p);

void __ovld vstore_half8_rtn(double8 data, size_t offset, __global half *p);

void __ovld vstore_half16_rtn(double16 data, size_t offset, __global half *p);

void __ovld vstore_half2(double2 data, size_t offset, __local half *p);

void __ovld vstore_half3(double3 data, size_t offset, __local half *p);

void __ovld vstore_half4(double4 data, size_t offset, __local half *p);

void __ovld vstore_half8(double8 data, size_t offset, __local half *p);

void __ovld vstore_half16(double16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rte(double2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rte(double3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rte(double4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rte(double8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rte(double16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rtz(double2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rtz(double3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rtz(double4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rtz(double8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rtz(double16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rtp(double2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rtp(double3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rtp(double4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rtp(double8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rtp(double16 data, size_t offset, __local half *p);

void __ovld vstore_half2_rtn(double2 data, size_t offset, __local half *p);

void __ovld vstore_half3_rtn(double3 data, size_t offset, __local half *p);

void __ovld vstore_half4_rtn(double4 data, size_t offset, __local half *p);

void __ovld vstore_half8_rtn(double8 data, size_t offset, __local half *p);

void __ovld vstore_half16_rtn(double16 data, size_t offset, __local half *p);

void __ovld vstore_half2(double2 data, size_t offset, __private half *p);

void __ovld vstore_half3(double3 data, size_t offset, __private half *p);

void __ovld vstore_half4(double4 data, size_t offset, __private half *p);

void __ovld vstore_half8(double8 data, size_t offset, __private half *p);

void __ovld vstore_half16(double16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rte(double2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rte(double3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rte(double4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rte(double8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rte(double16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rtz(double2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rtz(double3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rtz(double4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rtz(double8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rtz(double16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rtp(double2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rtp(double3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rtp(double4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rtp(double8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rtp(double16 data, size_t offset, __private half *p);

void __ovld vstore_half2_rtn(double2 data, size_t offset, __private half *p);

void __ovld vstore_half3_rtn(double3 data, size_t offset, __private half *p);

void __ovld vstore_half4_rtn(double4 data, size_t offset, __private half *p);

void __ovld vstore_half8_rtn(double8 data, size_t offset, __private half *p);

void __ovld vstore_half16_rtn(double16 data, size_t offset, __private half *p);

#endif //cl_khr_fp64

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


float __ovld vloada_half(size_t offset, const __constant half *p);

float2 __ovld vloada_half2(size_t offset, const __constant half *p);

float3 __ovld vloada_half3(size_t offset, const __constant half *p);

float4 __ovld vloada_half4(size_t offset, const __constant half *p);

float8 __ovld vloada_half8(size_t offset, const __constant half *p);

float16 __ovld vloada_half16(size_t offset, const __constant half *p);

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float __ovld vloada_half(size_t offset, const half *p);

float2 __ovld vloada_half2(size_t offset, const half *p);

float3 __ovld vloada_half3(size_t offset, const half *p);

float4 __ovld vloada_half4(size_t offset, const half *p);

float8 __ovld vloada_half8(size_t offset, const half *p);

float16 __ovld vloada_half16(size_t offset, const half *p);

#else

float __ovld vloada_half(size_t offset, const __global half *p);

float2 __ovld vloada_half2(size_t offset, const __global half *p);

float3 __ovld vloada_half3(size_t offset, const __global half *p);

float4 __ovld vloada_half4(size_t offset, const __global half *p);

float8 __ovld vloada_half8(size_t offset, const __global half *p);

float16 __ovld vloada_half16(size_t offset, const __global half *p);

float __ovld vloada_half(size_t offset, const __local half *p);

float2 __ovld vloada_half2(size_t offset, const __local half *p);

float3 __ovld vloada_half3(size_t offset, const __local half *p);

float4 __ovld vloada_half4(size_t offset, const __local half *p);

float8 __ovld vloada_half8(size_t offset, const __local half *p);

float16 __ovld vloada_half16(size_t offset, const __local half *p);

float __ovld vloada_half(size_t offset, const __private half *p);

float2 __ovld vloada_half2(size_t offset, const __private half *p);

float3 __ovld vloada_half3(size_t offset, const __private half *p);

float4 __ovld vloada_half4(size_t offset, const __private half *p);

float8 __ovld vloada_half8(size_t offset, const __private half *p);

float16 __ovld vloada_half16(size_t offset, const __private half *p);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __ovld vstorea_half(float data, size_t offset, half *p);

void __ovld vstorea_half2(float2 data, size_t offset, half *p);

void __ovld vstorea_half3(float3 data, size_t offset, half *p);

void __ovld vstorea_half4(float4 data, size_t offset, half *p);

void __ovld vstorea_half8(float8 data, size_t offset, half *p);

void __ovld vstorea_half16(float16 data, size_t offset, half *p);


void __ovld vstorea_half_rte(float data, size_t offset, half *p);

void __ovld vstorea_half2_rte(float2 data, size_t offset, half *p);

void __ovld vstorea_half3_rte(float3 data, size_t offset, half *p);

void __ovld vstorea_half4_rte(float4 data, size_t offset, half *p);

void __ovld vstorea_half8_rte(float8 data, size_t offset, half *p);

void __ovld vstorea_half16_rte(float16 data, size_t offset, half *p);


void __ovld vstorea_half_rtz(float data, size_t offset, half *p);

void __ovld vstorea_half2_rtz(float2 data, size_t offset, half *p);

void __ovld vstorea_half3_rtz(float3 data, size_t offset, half *p);

void __ovld vstorea_half4_rtz(float4 data, size_t offset, half *p);

void __ovld vstorea_half8_rtz(float8 data, size_t offset, half *p);

void __ovld vstorea_half16_rtz(float16 data, size_t offset, half *p);


void __ovld vstorea_half_rtp(float data, size_t offset, half *p);

void __ovld vstorea_half2_rtp(float2 data, size_t offset, half *p);

void __ovld vstorea_half3_rtp(float3 data, size_t offset, half *p);

void __ovld vstorea_half4_rtp(float4 data, size_t offset, half *p);

void __ovld vstorea_half8_rtp(float8 data, size_t offset, half *p);

void __ovld vstorea_half16_rtp(float16 data, size_t offset, half *p);


void __ovld vstorea_half_rtn(float data, size_t offset, half *p);

void __ovld vstorea_half2_rtn(float2 data, size_t offset, half *p);

void __ovld vstorea_half3_rtn(float3 data, size_t offset, half *p);

void __ovld vstorea_half4_rtn(float4 data, size_t offset, half *p);

void __ovld vstorea_half8_rtn(float8 data, size_t offset, half *p);

void __ovld vstorea_half16_rtn(float16 data, size_t offset, half *p);


#ifdef cl_khr_fp64

void __ovld vstorea_half(double data, size_t offset, half *p);

void __ovld vstorea_half2(double2 data, size_t offset, half *p);

void __ovld vstorea_half3(double3 data, size_t offset, half *p);

void __ovld vstorea_half4(double4 data, size_t offset, half *p);

void __ovld vstorea_half8(double8 data, size_t offset, half *p);

void __ovld vstorea_half16(double16 data, size_t offset, half *p);


void __ovld vstorea_half_rte(double data, size_t offset, half *p);

void __ovld vstorea_half2_rte(double2 data, size_t offset, half *p);

void __ovld vstorea_half3_rte(double3 data, size_t offset, half *p);

void __ovld vstorea_half4_rte(double4 data, size_t offset, half *p);

void __ovld vstorea_half8_rte(double8 data, size_t offset, half *p);

void __ovld vstorea_half16_rte(double16 data, size_t offset, half *p);


void __ovld vstorea_half_rtz(double data, size_t offset, half *p);

void __ovld vstorea_half2_rtz(double2 data, size_t offset, half *p);

void __ovld vstorea_half3_rtz(double3 data, size_t offset, half *p);

void __ovld vstorea_half4_rtz(double4 data, size_t offset, half *p);

void __ovld vstorea_half8_rtz(double8 data, size_t offset, half *p);

void __ovld vstorea_half16_rtz(double16 data, size_t offset, half *p);


void __ovld vstorea_half_rtp(double data, size_t offset, half *p);

void __ovld vstorea_half2_rtp(double2 data, size_t offset, half *p);

void __ovld vstorea_half3_rtp(double3 data, size_t offset, half *p);

void __ovld vstorea_half4_rtp(double4 data, size_t offset, half *p);

void __ovld vstorea_half8_rtp(double8 data, size_t offset, half *p);

void __ovld vstorea_half16_rtp(double16 data, size_t offset, half *p);


void __ovld vstorea_half_rtn(double data, size_t offset, half *p);

void __ovld vstorea_half2_rtn(double2 data, size_t offset, half *p);

void __ovld vstorea_half3_rtn(double3 data, size_t offset, half *p);

void __ovld vstorea_half4_rtn(double4 data, size_t offset, half *p);

void __ovld vstorea_half8_rtn(double8 data, size_t offset, half *p);

void __ovld vstorea_half16_rtn(double16 data, size_t offset, half *p);

#endif //cl_khr_fp64


#else

void __ovld vstorea_half(float data, size_t offset, __global half *p);

void __ovld vstorea_half2(float2 data, size_t offset, __global half *p);

void __ovld vstorea_half3(float3 data, size_t offset, __global half *p);

void __ovld vstorea_half4(float4 data, size_t offset, __global half *p);

void __ovld vstorea_half8(float8 data, size_t offset, __global half *p);

void __ovld vstorea_half16(float16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rte(float data, size_t offset, __global half *p);

void __ovld vstorea_half2_rte(float2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rte(float3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rte(float4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rte(float8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rte(float16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rtz(float data, size_t offset, __global half *p);

void __ovld vstorea_half2_rtz(float2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rtz(float3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rtz(float4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rtz(float8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rtz(float16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rtp(float data, size_t offset, __global half *p);

void __ovld vstorea_half2_rtp(float2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rtp(float3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rtp(float4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rtp(float8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rtp(float16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rtn(float data, size_t offset, __global half *p);

void __ovld vstorea_half2_rtn(float2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rtn(float3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rtn(float4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rtn(float8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rtn(float16 data, size_t offset, __global half *p);


void __ovld vstorea_half(float data, size_t offset, __local half *p);

void __ovld vstorea_half2(float2 data, size_t offset, __local half *p);

void __ovld vstorea_half3(float3 data, size_t offset, __local half *p);

void __ovld vstorea_half4(float4 data, size_t offset, __local half *p);

void __ovld vstorea_half8(float8 data, size_t offset, __local half *p);

void __ovld vstorea_half16(float16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rte(float data, size_t offset, __local half *p);

void __ovld vstorea_half2_rte(float2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rte(float3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rte(float4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rte(float8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rte(float16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rtz(float data, size_t offset, __local half *p);

void __ovld vstorea_half2_rtz(float2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rtz(float3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rtz(float4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rtz(float8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rtz(float16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rtp(float data, size_t offset, __local half *p);

void __ovld vstorea_half2_rtp(float2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rtp(float3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rtp(float4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rtp(float8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rtp(float16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rtn(float data, size_t offset, __local half *p);

void __ovld vstorea_half2_rtn(float2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rtn(float3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rtn(float4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rtn(float8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rtn(float16 data, size_t offset, __local half *p);


void __ovld vstorea_half(float data, size_t offset, __private half *p);

void __ovld vstorea_half2(float2 data, size_t offset, __private half *p);

void __ovld vstorea_half3(float3 data, size_t offset, __private half *p);

void __ovld vstorea_half4(float4 data, size_t offset, __private half *p);

void __ovld vstorea_half8(float8 data, size_t offset, __private half *p);

void __ovld vstorea_half16(float16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rte(float data, size_t offset, __private half *p);

void __ovld vstorea_half2_rte(float2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rte(float3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rte(float4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rte(float8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rte(float16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rtz(float data, size_t offset, __private half *p);

void __ovld vstorea_half2_rtz(float2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rtz(float3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rtz(float4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rtz(float8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rtz(float16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rtp(float data, size_t offset, __private half *p);

void __ovld vstorea_half2_rtp(float2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rtp(float3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rtp(float4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rtp(float8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rtp(float16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rtn(float data, size_t offset, __private half *p);

void __ovld vstorea_half2_rtn(float2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rtn(float3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rtn(float4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rtn(float8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rtn(float16 data, size_t offset, __private half *p);


#ifdef cl_khr_fp64

void __ovld vstorea_half(double data, size_t offset, __global half *p);

void __ovld vstorea_half2(double2 data, size_t offset, __global half *p);

void __ovld vstorea_half3(double3 data, size_t offset, __global half *p);

void __ovld vstorea_half4(double4 data, size_t offset, __global half *p);

void __ovld vstorea_half8(double8 data, size_t offset, __global half *p);

void __ovld vstorea_half16(double16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rte(double data, size_t offset, __global half *p);

void __ovld vstorea_half2_rte(double2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rte(double3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rte(double4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rte(double8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rte(double16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rtz(double data, size_t offset, __global half *p);

void __ovld vstorea_half2_rtz(double2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rtz(double3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rtz(double4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rtz(double8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rtz(double16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rtp(double data, size_t offset, __global half *p);

void __ovld vstorea_half2_rtp(double2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rtp(double3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rtp(double4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rtp(double8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rtp(double16 data, size_t offset, __global half *p);


void __ovld vstorea_half_rtn(double data, size_t offset, __global half *p);

void __ovld vstorea_half2_rtn(double2 data, size_t offset, __global half *p);

void __ovld vstorea_half3_rtn(double3 data, size_t offset, __global half *p);

void __ovld vstorea_half4_rtn(double4 data, size_t offset, __global half *p);

void __ovld vstorea_half8_rtn(double8 data, size_t offset, __global half *p);

void __ovld vstorea_half16_rtn(double16 data, size_t offset, __global half *p);


void __ovld vstorea_half(double data, size_t offset, __local half *p);

void __ovld vstorea_half2(double2 data, size_t offset, __local half *p);

void __ovld vstorea_half3(double3 data, size_t offset, __local half *p);

void __ovld vstorea_half4(double4 data, size_t offset, __local half *p);

void __ovld vstorea_half8(double8 data, size_t offset, __local half *p);

void __ovld vstorea_half16(double16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rte(double data, size_t offset, __local half *p);

void __ovld vstorea_half2_rte(double2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rte(double3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rte(double4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rte(double8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rte(double16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rtz(double data, size_t offset, __local half *p);

void __ovld vstorea_half2_rtz(double2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rtz(double3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rtz(double4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rtz(double8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rtz(double16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rtp(double data, size_t offset, __local half *p);

void __ovld vstorea_half2_rtp(double2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rtp(double3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rtp(double4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rtp(double8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rtp(double16 data, size_t offset, __local half *p);


void __ovld vstorea_half_rtn(double data, size_t offset, __local half *p);

void __ovld vstorea_half2_rtn(double2 data, size_t offset, __local half *p);

void __ovld vstorea_half3_rtn(double3 data, size_t offset, __local half *p);

void __ovld vstorea_half4_rtn(double4 data, size_t offset, __local half *p);

void __ovld vstorea_half8_rtn(double8 data, size_t offset, __local half *p);

void __ovld vstorea_half16_rtn(double16 data, size_t offset, __local half *p);


void __ovld vstorea_half(double data, size_t offset, __private half *p);

void __ovld vstorea_half2(double2 data, size_t offset, __private half *p);

void __ovld vstorea_half3(double3 data, size_t offset, __private half *p);

void __ovld vstorea_half4(double4 data, size_t offset, __private half *p);

void __ovld vstorea_half8(double8 data, size_t offset, __private half *p);

void __ovld vstorea_half16(double16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rte(double data, size_t offset, __private half *p);

void __ovld vstorea_half2_rte(double2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rte(double3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rte(double4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rte(double8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rte(double16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rtz(double data, size_t offset, __private half *p);

void __ovld vstorea_half2_rtz(double2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rtz(double3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rtz(double4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rtz(double8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rtz(double16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rtp(double data, size_t offset, __private half *p);

void __ovld vstorea_half2_rtp(double2 data, size_t offset, __private half *p);

void __ovld vstorea_half3_rtp(double3 data, size_t offset, __private half *p);

void __ovld vstorea_half4_rtp(double4 data, size_t offset, __private half *p);

void __ovld vstorea_half8_rtp(double8 data, size_t offset, __private half *p);

void __ovld vstorea_half16_rtp(double16 data, size_t offset, __private half *p);


void __ovld vstorea_half_rtn(double data, size_t offset, __private half *p);

void __ovld vstorea_half2_rtn(double2 data,size_t offset, __private half *p);

void __ovld vstorea_half3_rtn(double3 data,size_t offset, __private half *p);

void __ovld vstorea_half4_rtn(double4 data,size_t offset, __private half *p);

void __ovld vstorea_half8_rtn(double8 data,size_t offset, __private half *p);

void __ovld vstorea_half16_rtn(double16 data,size_t offset, __private half *p);

#endif //cl_khr_fp64

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions


void __ovld __conv barrier(cl_mem_fence_flags flags);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __ovld __conv work_group_barrier(cl_mem_fence_flags flags, memory_scope scope);

void __ovld __conv work_group_barrier(cl_mem_fence_flags flags);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v1.1 s6.11.9, v1.2 s6.12.9 - Explicit Memory Fence Functions


void __ovld mem_fence(cl_mem_fence_flags flags);


void __ovld read_mem_fence(cl_mem_fence_flags flags);


void __ovld write_mem_fence(cl_mem_fence_flags flags);


// OpenCL v2.0 s6.13.9 - Address Space Qualifier Functions


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

cl_mem_fence_flags __ovld get_fence(const void *ptr);

cl_mem_fence_flags __ovld get_fence(void *ptr);


#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10 - Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch


event_t __ovld async_work_group_copy(__local char *dst, const __global char *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uchar *dst, const __global uchar *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local short *dst, const __global short *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ushort *dst, const __global ushort *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local int *dst, const __global int *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uint *dst, const __global uint *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local long *dst, const __global long *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ulong *dst, const __global ulong *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local float *dst, const __global float *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local char2 *dst, const __global char2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uchar2 *dst, const __global uchar2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local short2 *dst, const __global short2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ushort2 *dst, const __global ushort2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local int2 *dst, const __global int2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uint2 *dst, const __global uint2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local long2 *dst, const __global long2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ulong2 *dst, const __global ulong2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local float2 *dst, const __global float2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local char3 *dst, const __global char3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uchar3 *dst, const __global uchar3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local short3 *dst, const __global short3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ushort3 *dst, const __global ushort3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local int3 *dst, const __global int3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uint3 *dst, const __global uint3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local long3 *dst, const __global long3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ulong3 *dst, const __global ulong3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local float3 *dst, const __global float3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local char4 *dst, const __global char4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uchar4 *dst, const __global uchar4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local short4 *dst, const __global short4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ushort4 *dst, const __global ushort4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local int4 *dst, const __global int4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uint4 *dst, const __global uint4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local long4 *dst, const __global long4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ulong4 *dst, const __global ulong4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local float4 *dst, const __global float4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local char8 *dst, const __global char8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uchar8 *dst, const __global uchar8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local short8 *dst, const __global short8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ushort8 *dst, const __global ushort8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local int8 *dst, const __global int8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uint8 *dst, const __global uint8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local long8 *dst, const __global long8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ulong8 *dst, const __global ulong8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local float8 *dst, const __global float8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local char16 *dst, const __global char16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uchar16 *dst, const __global uchar16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local short16 *dst, const __global short16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ushort16 *dst, const __global ushort16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local int16 *dst, const __global int16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local uint16 *dst, const __global uint16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local long16 *dst, const __global long16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local ulong16 *dst, const __global ulong16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local float16 *dst, const __global float16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global char *dst, const __local char *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uchar *dst, const __local uchar *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global short *dst, const __local short *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ushort *dst, const __local ushort *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global int *dst, const __local int *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uint *dst, const __local uint *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global long *dst, const __local long *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ulong *dst, const __local ulong *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global float *dst, const __local float *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global char2 *dst, const __local char2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uchar2 *dst, const __local uchar2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global short2 *dst, const __local short2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ushort2 *dst, const __local ushort2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global int2 *dst, const __local int2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uint2 *dst, const __local uint2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global long2 *dst, const __local long2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ulong2 *dst, const __local ulong2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global float2 *dst, const __local float2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global char3 *dst, const __local char3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uchar3 *dst, const __local uchar3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global short3 *dst, const __local short3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ushort3 *dst, const __local ushort3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global int3 *dst, const __local int3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uint3 *dst, const __local uint3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global long3 *dst, const __local long3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ulong3 *dst, const __local ulong3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global float3 *dst, const __local float3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global char4 *dst, const __local char4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uchar4 *dst, const __local uchar4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global short4 *dst, const __local short4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ushort4 *dst, const __local ushort4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global int4 *dst, const __local int4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uint4 *dst, const __local uint4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global long4 *dst, const __local long4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ulong4 *dst, const __local ulong4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global float4 *dst, const __local float4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global char8 *dst, const __local char8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uchar8 *dst, const __local uchar8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global short8 *dst, const __local short8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ushort8 *dst, const __local ushort8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global int8 *dst, const __local int8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uint8 *dst, const __local uint8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global long8 *dst, const __local long8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ulong8 *dst, const __local ulong8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global float8 *dst, const __local float8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global char16 *dst, const __local char16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uchar16 *dst, const __local uchar16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global short16 *dst, const __local short16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ushort16 *dst, const __local ushort16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global int16 *dst, const __local int16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global uint16 *dst, const __local uint16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, event_t event);

#ifdef cl_khr_fp64

event_t __ovld async_work_group_copy(__local double *dst, const __global double *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local double4 *dst, const __global double4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local double8 *dst, const __global double8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local double16 *dst, const __global double16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global double *dst, const __local double *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global double2 *dst, const __local double2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global double3 *dst, const __local double3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, event_t event);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

event_t __ovld async_work_group_copy(__local half *dst, const __global half *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local half3 *dst, const __global half3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local half4 *dst, const __global half4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local half8 *dst, const __global half8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__local half16 *dst, const __global half16 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global half *dst, const __local half *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global half2 *dst, const __local half2 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global half3 *dst, const __local half3 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global half4 *dst, const __local half4 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global half8 *dst, const __local half8 *src, size_t num_elements, event_t event);

event_t __ovld async_work_group_copy(__global half16 *dst, const __local half16 *src, size_t num_elements, event_t event);

#endif //cl_khr_fp16


event_t __ovld async_work_group_strided_copy(__local char *dst, const __global char *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uchar *dst, const __global uchar *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local short *dst, const __global short *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ushort *dst, const __global ushort *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local int *dst, const __global int *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uint *dst, const __global uint *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local long *dst, const __global long *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ulong *dst, const __global ulong *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local float *dst, const __global float *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local char2 *dst, const __global char2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uchar2 *dst, const __global uchar2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local short2 *dst, const __global short2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ushort2 *dst, const __global ushort2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local int2 *dst, const __global int2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uint2 *dst, const __global uint2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local long2 *dst, const __global long2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ulong2 *dst, const __global ulong2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local float2 *dst, const __global float2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local char3 *dst, const __global char3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uchar3 *dst, const __global uchar3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local short3 *dst, const __global short3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ushort3 *dst, const __global ushort3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local int3 *dst, const __global int3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uint3 *dst, const __global uint3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local long3 *dst, const __global long3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ulong3 *dst, const __global ulong3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local float3 *dst, const __global float3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local char4 *dst, const __global char4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uchar4 *dst, const __global uchar4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local short4 *dst, const __global short4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ushort4 *dst, const __global ushort4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local int4 *dst, const __global int4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uint4 *dst, const __global uint4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local long4 *dst, const __global long4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ulong4 *dst, const __global ulong4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local float4 *dst, const __global float4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local char8 *dst, const __global char8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uchar8 *dst, const __global uchar8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local short8 *dst, const __global short8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ushort8 *dst, const __global ushort8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local int8 *dst, const __global int8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uint8 *dst, const __global uint8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local long8 *dst, const __global long8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ulong8 *dst, const __global ulong8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local float8 *dst, const __global float8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local char16 *dst, const __global char16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uchar16 *dst, const __global uchar16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local short16 *dst, const __global short16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ushort16 *dst, const __global ushort16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local int16 *dst, const __global int16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local uint16 *dst, const __global uint16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local long16 *dst, const __global long16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local ulong16 *dst, const __global ulong16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local float16 *dst, const __global float16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global char *dst, const __local char *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uchar *dst, const __local uchar *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global short *dst, const __local short *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ushort *dst, const __local ushort *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global int *dst, const __local int *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uint *dst, const __local uint *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global long *dst, const __local long *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ulong *dst, const __local ulong *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global float *dst, const __local float *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global char2 *dst, const __local char2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uchar2 *dst, const __local uchar2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global short2 *dst, const __local short2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ushort2 *dst, const __local ushort2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global int2 *dst, const __local int2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uint2 *dst, const __local uint2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global long2 *dst, const __local long2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ulong2 *dst, const __local ulong2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global float2 *dst, const __local float2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global char3 *dst, const __local char3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uchar3 *dst, const __local uchar3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global short3 *dst, const __local short3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ushort3 *dst, const __local ushort3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global int3 *dst, const __local int3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uint3 *dst, const __local uint3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global long3 *dst, const __local long3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ulong3 *dst, const __local ulong3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global float3 *dst, const __local float3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global char4 *dst, const __local char4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uchar4 *dst, const __local uchar4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global short4 *dst, const __local short4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ushort4 *dst, const __local ushort4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global int4 *dst, const __local int4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uint4 *dst, const __local uint4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global long4 *dst, const __local long4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ulong4 *dst, const __local ulong4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global float4 *dst, const __local float4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global char8 *dst, const __local char8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uchar8 *dst, const __local uchar8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global short8 *dst, const __local short8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ushort8 *dst, const __local ushort8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global int8 *dst, const __local int8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uint8 *dst, const __local uint8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global long8 *dst, const __local long8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ulong8 *dst, const __local ulong8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global float8 *dst, const __local float8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global char16 *dst, const __local char16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uchar16 *dst, const __local uchar16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global short16 *dst, const __local short16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ushort16 *dst, const __local ushort16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global int16 *dst, const __local int16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global uint16 *dst, const __local uint16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, size_t dst_stride, event_t event);

#ifdef cl_khr_fp64

event_t __ovld async_work_group_strided_copy(__local double *dst, const __global double *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local double4 *dst, const __global double4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local double8 *dst, const __global double8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local double16 *dst, const __global double16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global double *dst, const __local double *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global double2 *dst, const __local double2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global double3 *dst, const __local double3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, size_t dst_stride, event_t event);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

event_t __ovld async_work_group_strided_copy(__local half *dst, const __global half *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local half3 *dst, const __global half3 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local half4 *dst, const __global half4 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local half8 *dst, const __global half8 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__local half16 *dst, const __global half16 *src, size_t num_elements, size_t src_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global half *dst, const __local half *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global half2 *dst, const __local half2 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global half3 *dst, const __local half3 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global half4 *dst, const __local half4 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global half8 *dst, const __local half8 *src, size_t num_elements, size_t dst_stride, event_t event);

event_t __ovld async_work_group_strided_copy(__global half16 *dst, const __local half16 *src, size_t num_elements, size_t dst_stride, event_t event);

#endif //cl_khr_fp16


void __ovld wait_group_events(int num_events, event_t *event_list);


void __ovld prefetch(const __global char *p, size_t num_elements);

void __ovld prefetch(const __global uchar *p, size_t num_elements);

void __ovld prefetch(const __global short *p, size_t num_elements);

void __ovld prefetch(const __global ushort *p, size_t num_elements);

void __ovld prefetch(const __global int *p, size_t num_elements);

void __ovld prefetch(const __global uint *p, size_t num_elements);

void __ovld prefetch(const __global long *p, size_t num_elements);

void __ovld prefetch(const __global ulong *p, size_t num_elements);

void __ovld prefetch(const __global float *p, size_t num_elements);

void __ovld prefetch(const __global char2 *p, size_t num_elements);

void __ovld prefetch(const __global uchar2 *p, size_t num_elements);

void __ovld prefetch(const __global short2 *p, size_t num_elements);

void __ovld prefetch(const __global ushort2 *p, size_t num_elements);

void __ovld prefetch(const __global int2 *p, size_t num_elements);

void __ovld prefetch(const __global uint2 *p, size_t num_elements);

void __ovld prefetch(const __global long2 *p, size_t num_elements);

void __ovld prefetch(const __global ulong2 *p, size_t num_elements);

void __ovld prefetch(const __global float2 *p, size_t num_elements);

void __ovld prefetch(const __global char3 *p, size_t num_elements);

void __ovld prefetch(const __global uchar3 *p, size_t num_elements);

void __ovld prefetch(const __global short3 *p, size_t num_elements);

void __ovld prefetch(const __global ushort3 *p, size_t num_elements);

void __ovld prefetch(const __global int3 *p, size_t num_elements);

void __ovld prefetch(const __global uint3 *p, size_t num_elements);

void __ovld prefetch(const __global long3 *p, size_t num_elements);

void __ovld prefetch(const __global ulong3 *p, size_t num_elements);

void __ovld prefetch(const __global float3 *p, size_t num_elements);

void __ovld prefetch(const __global char4 *p, size_t num_elements);

void __ovld prefetch(const __global uchar4 *p, size_t num_elements);

void __ovld prefetch(const __global short4 *p, size_t num_elements);

void __ovld prefetch(const __global ushort4 *p, size_t num_elements);

void __ovld prefetch(const __global int4 *p, size_t num_elements);

void __ovld prefetch(const __global uint4 *p, size_t num_elements);

void __ovld prefetch(const __global long4 *p, size_t num_elements);

void __ovld prefetch(const __global ulong4 *p, size_t num_elements);

void __ovld prefetch(const __global float4 *p, size_t num_elements);

void __ovld prefetch(const __global char8 *p, size_t num_elements);

void __ovld prefetch(const __global uchar8 *p, size_t num_elements);

void __ovld prefetch(const __global short8 *p, size_t num_elements);

void __ovld prefetch(const __global ushort8 *p, size_t num_elements);

void __ovld prefetch(const __global int8 *p, size_t num_elements);

void __ovld prefetch(const __global uint8 *p, size_t num_elements);

void __ovld prefetch(const __global long8 *p, size_t num_elements);

void __ovld prefetch(const __global ulong8 *p, size_t num_elements);

void __ovld prefetch(const __global float8 *p, size_t num_elements);

void __ovld prefetch(const __global char16 *p, size_t num_elements);

void __ovld prefetch(const __global uchar16 *p, size_t num_elements);

void __ovld prefetch(const __global short16 *p, size_t num_elements);

void __ovld prefetch(const __global ushort16 *p, size_t num_elements);

void __ovld prefetch(const __global int16 *p, size_t num_elements);

void __ovld prefetch(const __global uint16 *p, size_t num_elements);

void __ovld prefetch(const __global long16 *p, size_t num_elements);

void __ovld prefetch(const __global ulong16 *p, size_t num_elements);

void __ovld prefetch(const __global float16 *p, size_t num_elements);

#ifdef cl_khr_fp64

void __ovld prefetch(const __global double *p, size_t num_elements);

void __ovld prefetch(const __global double2 *p, size_t num_elements);

void __ovld prefetch(const __global double3 *p, size_t num_elements);

void __ovld prefetch(const __global double4 *p, size_t num_elements);

void __ovld prefetch(const __global double8 *p, size_t num_elements);

void __ovld prefetch(const __global double16 *p, size_t num_elements);

#endif //cl_khr_fp64

#ifdef cl_khr_fp16

void __ovld prefetch(const __global half *p, size_t num_elements);

void __ovld prefetch(const __global half2 *p, size_t num_elements);

void __ovld prefetch(const __global half3 *p, size_t num_elements);

void __ovld prefetch(const __global half4 *p, size_t num_elements);

void __ovld prefetch(const __global half8 *p, size_t num_elements);

void __ovld prefetch(const __global half16 *p, size_t num_elements);

#endif // cl_khr_fp16


// OpenCL v1.1 s6.11.1, v1.2 s6.12.11 - Atomic Functions


#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable

#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable

#endif

int __ovld atomic_add(volatile __global int *p, int val);

unsigned int __ovld atomic_add(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_add(volatile __local int *p, int val);

unsigned int __ovld atomic_add(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_add(volatile int *p, int val);

unsigned int __ovld atomic_add(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_base_atomics)

int __ovld atom_add(volatile __global int *p, int val);

unsigned int __ovld atom_add(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_base_atomics)

int __ovld atom_add(volatile __local int *p, int val);

unsigned int __ovld atom_add(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_base_atomics)

long __ovld atom_add(volatile __global long *p, long val);

unsigned long __ovld atom_add(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_add(volatile __local long *p, long val);

unsigned long __ovld atom_add(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_sub(volatile __global int *p, int val);

unsigned int __ovld atomic_sub(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_sub(volatile __local int *p, int val);

unsigned int __ovld atomic_sub(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_sub(volatile int *p, int val);

unsigned int __ovld atomic_sub(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_base_atomics)

int __ovld atom_sub(volatile __global int *p, int val);

unsigned int __ovld atom_sub(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_base_atomics)

int __ovld atom_sub(volatile __local int *p, int val);

unsigned int __ovld atom_sub(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_base_atomics)

long __ovld atom_sub(volatile __global long *p, long val);

unsigned long __ovld atom_sub(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_sub(volatile __local long *p, long val);

unsigned long __ovld atom_sub(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_xchg(volatile __global int *p, int val);

unsigned int __ovld atomic_xchg(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_xchg(volatile __local int *p, int val);

unsigned int __ovld atomic_xchg(volatile __local unsigned int *p, unsigned int val);

float __ovld atomic_xchg(volatile __global float *p, float val);

float __ovld atomic_xchg(volatile __local float *p, float val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_xchg(volatile int *p, int val);

unsigned int __ovld atomic_xchg(volatile unsigned int *p, unsigned int val);

float __ovld atomic_xchg(volatile float *p, float val);

#endif


#if defined(cl_khr_global_int32_base_atomics)

int __ovld atom_xchg(volatile __global int *p, int val);

unsigned int __ovld atom_xchg(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_base_atomics)

int __ovld atom_xchg(volatile __local int *p, int val);

unsigned int __ovld atom_xchg(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_base_atomics)

long __ovld atom_xchg(volatile __global long *p, long val);

long __ovld atom_xchg(volatile __local long *p, long val);

unsigned long __ovld atom_xchg(volatile __global unsigned long *p, unsigned long val);

unsigned long __ovld atom_xchg(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_inc(volatile __global int *p);

unsigned int __ovld atomic_inc(volatile __global unsigned int *p);

int __ovld atomic_inc(volatile __local int *p);

unsigned int __ovld atomic_inc(volatile __local unsigned int *p);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_inc(volatile int *p);

unsigned int __ovld atomic_inc(volatile unsigned int *p);

#endif


#if defined(cl_khr_global_int32_base_atomics)

int __ovld atom_inc(volatile __global int *p);

unsigned int __ovld atom_inc(volatile __global unsigned int *p);

#endif

#if defined(cl_khr_local_int32_base_atomics)

int __ovld atom_inc(volatile __local int *p);

unsigned int __ovld atom_inc(volatile __local unsigned int *p);

#endif


#if defined(cl_khr_int64_base_atomics)

long __ovld atom_inc(volatile __global long *p);

unsigned long __ovld atom_inc(volatile __global unsigned long *p);

long __ovld atom_inc(volatile __local long *p);

unsigned long __ovld atom_inc(volatile __local unsigned long *p);

#endif


int __ovld atomic_dec(volatile __global int *p);

unsigned int __ovld atomic_dec(volatile __global unsigned int *p);

int __ovld atomic_dec(volatile __local int *p);

unsigned int __ovld atomic_dec(volatile __local unsigned int *p);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_dec(volatile int *p);

unsigned int __ovld atomic_dec(volatile unsigned int *p);

#endif


#if defined(cl_khr_global_int32_base_atomics)

int __ovld atom_dec(volatile __global int *p);

unsigned int __ovld atom_dec(volatile __global unsigned int *p);

#endif

#if defined(cl_khr_local_int32_base_atomics)

int __ovld atom_dec(volatile __local int *p);

unsigned int __ovld atom_dec(volatile __local unsigned int *p);

#endif


#if defined(cl_khr_int64_base_atomics)

long __ovld atom_dec(volatile __global long *p);

unsigned long __ovld atom_dec(volatile __global unsigned long *p);

long __ovld atom_dec(volatile __local long *p);

unsigned long __ovld atom_dec(volatile __local unsigned long *p);

#endif


int __ovld atomic_cmpxchg(volatile __global int *p, int cmp, int val);

unsigned int __ovld atomic_cmpxchg(volatile __global unsigned int *p, unsigned int cmp, unsigned int val);

int __ovld atomic_cmpxchg(volatile __local int *p, int cmp, int val);

unsigned int __ovld atomic_cmpxchg(volatile __local unsigned int *p, unsigned int cmp, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_cmpxchg(volatile int *p, int cmp, int val);

unsigned int __ovld atomic_cmpxchg(volatile unsigned int *p, unsigned int cmp, unsigned int val);

#endif


#if defined(cl_khr_global_int32_base_atomics)

int __ovld atom_cmpxchg(volatile __global int *p, int cmp, int val);

unsigned int __ovld atom_cmpxchg(volatile __global unsigned int *p, unsigned int cmp, unsigned int val);

#endif

#if defined(cl_khr_local_int32_base_atomics)

int __ovld atom_cmpxchg(volatile __local int *p, int cmp, int val);

unsigned int __ovld atom_cmpxchg(volatile __local unsigned int *p, unsigned int cmp, unsigned int val);

#endif


#if defined(cl_khr_int64_base_atomics)

long __ovld atom_cmpxchg(volatile __global long *p, long cmp, long val);

unsigned long __ovld atom_cmpxchg(volatile __global unsigned long *p, unsigned long cmp, unsigned long val);

long __ovld atom_cmpxchg(volatile __local long *p, long cmp, long val);

unsigned long __ovld atom_cmpxchg(volatile __local unsigned long *p, unsigned long cmp, unsigned long val);

#endif


int __ovld atomic_min(volatile __global int *p, int val);

unsigned int __ovld atomic_min(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_min(volatile __local int *p, int val);

unsigned int __ovld atomic_min(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_min(volatile int *p, int val);

unsigned int __ovld atomic_min(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_extended_atomics)

int __ovld atom_min(volatile __global int *p, int val);

unsigned int __ovld atom_min(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_extended_atomics)

int __ovld atom_min(volatile __local int *p, int val);

unsigned int __ovld atom_min(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_extended_atomics)

long __ovld atom_min(volatile __global long *p, long val);

unsigned long __ovld atom_min(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_min(volatile __local long *p, long val);

unsigned long __ovld atom_min(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_max(volatile __global int *p, int val);

unsigned int __ovld atomic_max(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_max(volatile __local int *p, int val);

unsigned int __ovld atomic_max(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_max(volatile int *p, int val);

unsigned int __ovld atomic_max(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_extended_atomics)

int __ovld atom_max(volatile __global int *p, int val);

unsigned int __ovld atom_max(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_extended_atomics)

int __ovld atom_max(volatile __local int *p, int val);

unsigned int __ovld atom_max(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_extended_atomics)

long __ovld atom_max(volatile __global long *p, long val);

unsigned long __ovld atom_max(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_max(volatile __local long *p, long val);

unsigned long __ovld atom_max(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_and(volatile __global int *p, int val);

unsigned int __ovld atomic_and(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_and(volatile __local int *p, int val);

unsigned int __ovld atomic_and(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_and(volatile int *p, int val);

unsigned int __ovld atomic_and(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_extended_atomics)

int __ovld atom_and(volatile __global int *p, int val);

unsigned int __ovld atom_and(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_extended_atomics)

int __ovld atom_and(volatile __local int *p, int val);

unsigned int __ovld atom_and(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_extended_atomics)

long __ovld atom_and(volatile __global long *p, long val);

unsigned long __ovld atom_and(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_and(volatile __local long *p, long val);

unsigned long __ovld atom_and(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_or(volatile __global int *p, int val);

unsigned int __ovld atomic_or(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_or(volatile __local int *p, int val);

unsigned int __ovld atomic_or(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_or(volatile int *p, int val);

unsigned int __ovld atomic_or(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_extended_atomics)

int __ovld atom_or(volatile __global int *p, int val);

unsigned int __ovld atom_or(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_extended_atomics)

int __ovld atom_or(volatile __local int *p, int val);

unsigned int __ovld atom_or(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_extended_atomics)

long __ovld atom_or(volatile __global long *p, long val);

unsigned long __ovld atom_or(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_or(volatile __local long *p, long val);

unsigned long __ovld atom_or(volatile __local unsigned long *p, unsigned long val);

#endif


int __ovld atomic_xor(volatile __global int *p, int val);

unsigned int __ovld atomic_xor(volatile __global unsigned int *p, unsigned int val);

int __ovld atomic_xor(volatile __local int *p, int val);

unsigned int __ovld atomic_xor(volatile __local unsigned int *p, unsigned int val);

#ifdef __OPENCL_CPP_VERSION__

int __ovld atomic_xor(volatile int *p, int val);

unsigned int __ovld atomic_xor(volatile unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_global_int32_extended_atomics)

int __ovld atom_xor(volatile __global int *p, int val);

unsigned int __ovld atom_xor(volatile __global unsigned int *p, unsigned int val);

#endif

#if defined(cl_khr_local_int32_extended_atomics)

int __ovld atom_xor(volatile __local int *p, int val);

unsigned int __ovld atom_xor(volatile __local unsigned int *p, unsigned int val);

#endif


#if defined(cl_khr_int64_extended_atomics)

long __ovld atom_xor(volatile __global long *p, long val);

unsigned long __ovld atom_xor(volatile __global unsigned long *p, unsigned long val);

long __ovld atom_xor(volatile __local long *p, long val);

unsigned long __ovld atom_xor(volatile __local unsigned long *p, unsigned long val);

#endif


#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : disable

#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : disable

#endif


// OpenCL v2.0 s6.13.11 - Atomics Functions


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// double atomics support requires extensions cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics

#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable

#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable

#endif


// atomic_init()

void __ovld atomic_init(volatile atomic_int *object, int value);

void __ovld atomic_init(volatile atomic_uint *object, uint value);

void __ovld atomic_init(volatile atomic_float *object, float value);

#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

void __ovld atomic_init(volatile atomic_long *object, long value);

void __ovld atomic_init(volatile atomic_ulong *object, ulong value);

#ifdef cl_khr_fp64

void __ovld atomic_init(volatile atomic_double *object, double value);

#endif //cl_khr_fp64

#endif


// atomic_work_item_fence()

void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope);


// atomic_fetch()


int __ovld atomic_fetch_add(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_add(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);

int __ovld atomic_fetch_sub(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_sub(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);

int __ovld atomic_fetch_or(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_or(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);

int __ovld atomic_fetch_xor(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_xor(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);

int __ovld atomic_fetch_and(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_and(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);

int __ovld atomic_fetch_min(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_min(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);

int __ovld atomic_fetch_max(volatile atomic_int *object, int operand);

int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order);

int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);

uint __ovld atomic_fetch_max(volatile atomic_uint *object, uint operand);

uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, uint operand, memory_order order);

uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);


#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

long __ovld atomic_fetch_add(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_add_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_add_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_add(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

long __ovld atomic_fetch_sub(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_sub(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

long __ovld atomic_fetch_or(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_or(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

long __ovld atomic_fetch_xor(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_xor(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

long __ovld atomic_fetch_and(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_and(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

long __ovld atomic_fetch_min(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_min(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

long __ovld atomic_fetch_max(volatile atomic_long *object, long operand);

long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order);

long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);

ulong __ovld atomic_fetch_max(volatile atomic_ulong *object, ulong operand);

ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);

ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);

#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)


// OpenCL v2.0 s6.13.11.7.5:

// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument can be ptrdiff_t.

// or/xor/and/min/max: atomic type argument can be intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.


#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object, ptrdiff_t operand);

uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);

uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);

uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object, ptrdiff_t operand);

uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);

uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);


uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t *object, intptr_t operand);

uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);

uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);

uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t *object, intptr_t operand);

uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);

uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);

uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t *object, intptr_t operand);

uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);

uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);

uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t *object, intptr_t opermax);

uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder);

uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder, memory_scope scope);

uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t *object, intptr_t opermax);

uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder);

uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder, memory_scope scope);


intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t *object, uintptr_t operand);

intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);

intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);

intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t *object, uintptr_t operand);

intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);

intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);

intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t *object, uintptr_t operand);

intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);

intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);

intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t *object, uintptr_t opermax);

intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder);

intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder, memory_scope scope);

intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t *object, uintptr_t opermax);

intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder);

intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder, memory_scope scope);

#endif


// atomic_store()


void __ovld atomic_store(volatile atomic_int *object, int desired);

void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order);

void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);

void __ovld atomic_store(volatile atomic_uint *object, uint desired);

void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order);

void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);

void __ovld atomic_store(volatile atomic_float *object, float desired);

void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order);

void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);

#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#ifdef cl_khr_fp64

void __ovld atomic_store(volatile atomic_double *object, double desired);

void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order);

void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);

#endif //cl_khr_fp64

void __ovld atomic_store(volatile atomic_long *object, long desired);

void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order);

void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);

void __ovld atomic_store(volatile atomic_ulong *object, ulong desired);

void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);

void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);

#endif


// atomic_load()


int __ovld atomic_load(volatile atomic_int *object);

int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order);

int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order, memory_scope scope);

uint __ovld atomic_load(volatile atomic_uint *object);

uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order);

uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order, memory_scope scope);

float __ovld atomic_load(volatile atomic_float *object);

float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order);

float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order, memory_scope scope);

#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#ifdef cl_khr_fp64

double __ovld atomic_load(volatile atomic_double *object);

double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order);

double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order, memory_scope scope);

#endif //cl_khr_fp64

long __ovld atomic_load(volatile atomic_long *object);

long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order);

long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order, memory_scope scope);

ulong __ovld atomic_load(volatile atomic_ulong *object);

ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order);

ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order, memory_scope scope);

#endif


// atomic_exchange()


int __ovld atomic_exchange(volatile atomic_int *object, int desired);

int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order);

int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);

uint __ovld atomic_exchange(volatile atomic_uint *object, uint desired);

uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order);

uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);

float __ovld atomic_exchange(volatile atomic_float *object, float desired);

float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order);

float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);

#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#ifdef cl_khr_fp64

double __ovld atomic_exchange(volatile atomic_double *object, double desired);

double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order);

double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);

#endif //cl_khr_fp64

long __ovld atomic_exchange(volatile atomic_long *object, long desired);

long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order);

long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);

ulong __ovld atomic_exchange(volatile atomic_ulong *object, ulong desired);

ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);

ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);

#endif


// atomic_compare_exchange_strong() and atomic_compare_exchange_weak()


bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object, int *expected, int desired);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,

                                                                                 int desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,

                                                                                 int desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object, uint *expected, uint desired);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,

                                                                                 uint desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,

                                                                                 uint desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object, int *expected, int desired);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,

                                                                                 int desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,

                                                                                 int desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object, uint *expected, uint desired);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,

                                                                                 uint desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,

                                                                                 uint desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object, float *expected, float desired);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,

                                                                                 float desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,

                                                                                 float desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object, float *expected, float desired);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,

                                                                                 float desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,

                                                                                 float desired, memory_order success, memory_order failure, memory_scope scope);

#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)

#ifdef cl_khr_fp64

bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object, double *expected, double desired);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,

                                                                                 double desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,

                                                                                 double desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object, double *expected, double desired);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,

                                                                                 double desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,

                                                                                 double desired, memory_order success, memory_order failure, memory_scope scope);

#endif //cl_khr_fp64

bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object, long *expected, long desired);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,

                                                                                 long desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,

                                                                                 long desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object, long *expected, long desired);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,

                                                                                 long desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,

                                                                                 long desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object, ulong *expected, ulong desired);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,

                                                                                 ulong desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,

                                                                                 ulong desired, memory_order success, memory_order failure, memory_scope scope);

bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object, ulong *expected, ulong desired);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,

                                                                                 ulong desired, memory_order success, memory_order failure);

bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,

                                                                                 ulong desired, memory_order success, memory_order failure, memory_scope scope);

#endif


// atomic_flag_test_and_set() and atomic_flag_clear()


bool __ovld atomic_flag_test_and_set(volatile atomic_flag *object);

bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);

bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);

void __ovld atomic_flag_clear(volatile atomic_flag *object);

void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);

void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);


#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions


char2 __ovld __cnfn shuffle(char2 x, uchar2 mask);

char2 __ovld __cnfn shuffle(char4 x, uchar2 mask);

char2 __ovld __cnfn shuffle(char8 x, uchar2 mask);

char2 __ovld __cnfn shuffle(char16 x, uchar2 mask);


uchar2 __ovld __cnfn shuffle(uchar2 x, uchar2 mask);

uchar2 __ovld __cnfn shuffle(uchar4 x, uchar2 mask);

uchar2 __ovld __cnfn shuffle(uchar8 x, uchar2 mask);

uchar2 __ovld __cnfn shuffle(uchar16 x, uchar2 mask);


short2 __ovld __cnfn shuffle(short2 x, ushort2 mask);

short2 __ovld __cnfn shuffle(short4 x, ushort2 mask);

short2 __ovld __cnfn shuffle(short8 x, ushort2 mask);

short2 __ovld __cnfn shuffle(short16 x, ushort2 mask);


ushort2 __ovld __cnfn shuffle(ushort2 x, ushort2 mask);

ushort2 __ovld __cnfn shuffle(ushort4 x, ushort2 mask);

ushort2 __ovld __cnfn shuffle(ushort8 x, ushort2 mask);

ushort2 __ovld __cnfn shuffle(ushort16 x, ushort2 mask);


int2 __ovld __cnfn shuffle(int2 x, uint2 mask);

int2 __ovld __cnfn shuffle(int4 x, uint2 mask);

int2 __ovld __cnfn shuffle(int8 x, uint2 mask);

int2 __ovld __cnfn shuffle(int16 x, uint2 mask);


uint2 __ovld __cnfn shuffle(uint2 x, uint2 mask);

uint2 __ovld __cnfn shuffle(uint4 x, uint2 mask);

uint2 __ovld __cnfn shuffle(uint8 x, uint2 mask);

uint2 __ovld __cnfn shuffle(uint16 x, uint2 mask);


long2 __ovld __cnfn shuffle(long2 x, ulong2 mask);

long2 __ovld __cnfn shuffle(long4 x, ulong2 mask);

long2 __ovld __cnfn shuffle(long8 x, ulong2 mask);

long2 __ovld __cnfn shuffle(long16 x, ulong2 mask);


ulong2 __ovld __cnfn shuffle(ulong2 x, ulong2 mask);

ulong2 __ovld __cnfn shuffle(ulong4 x, ulong2 mask);

ulong2 __ovld __cnfn shuffle(ulong8 x, ulong2 mask);

ulong2 __ovld __cnfn shuffle(ulong16 x, ulong2 mask);


float2 __ovld __cnfn shuffle(float2 x, uint2 mask);

float2 __ovld __cnfn shuffle(float4 x, uint2 mask);

float2 __ovld __cnfn shuffle(float8 x, uint2 mask);

float2 __ovld __cnfn shuffle(float16 x, uint2 mask);


char4 __ovld __cnfn shuffle(char2 x, uchar4 mask);

char4 __ovld __cnfn shuffle(char4 x, uchar4 mask);

char4 __ovld __cnfn shuffle(char8 x, uchar4 mask);

char4 __ovld __cnfn shuffle(char16 x, uchar4 mask);


uchar4 __ovld __cnfn shuffle(uchar2 x, uchar4 mask);

uchar4 __ovld __cnfn shuffle(uchar4 x, uchar4 mask);

uchar4 __ovld __cnfn shuffle(uchar8 x, uchar4 mask);

uchar4 __ovld __cnfn shuffle(uchar16 x, uchar4 mask);


short4 __ovld __cnfn shuffle(short2 x, ushort4 mask);

short4 __ovld __cnfn shuffle(short4 x, ushort4 mask);

short4 __ovld __cnfn shuffle(short8 x, ushort4 mask);

short4 __ovld __cnfn shuffle(short16 x, ushort4 mask);


ushort4 __ovld __cnfn shuffle(ushort2 x, ushort4 mask);

ushort4 __ovld __cnfn shuffle(ushort4 x, ushort4 mask);

ushort4 __ovld __cnfn shuffle(ushort8 x, ushort4 mask);

ushort4 __ovld __cnfn shuffle(ushort16 x, ushort4 mask);


int4 __ovld __cnfn shuffle(int2 x, uint4 mask);

int4 __ovld __cnfn shuffle(int4 x, uint4 mask);

int4 __ovld __cnfn shuffle(int8 x, uint4 mask);

int4 __ovld __cnfn shuffle(int16 x, uint4 mask);


uint4 __ovld __cnfn shuffle(uint2 x, uint4 mask);

uint4 __ovld __cnfn shuffle(uint4 x, uint4 mask);

uint4 __ovld __cnfn shuffle(uint8 x, uint4 mask);

uint4 __ovld __cnfn shuffle(uint16 x, uint4 mask);


long4 __ovld __cnfn shuffle(long2 x, ulong4 mask);

long4 __ovld __cnfn shuffle(long4 x, ulong4 mask);

long4 __ovld __cnfn shuffle(long8 x, ulong4 mask);

long4 __ovld __cnfn shuffle(long16 x, ulong4 mask);


ulong4 __ovld __cnfn shuffle(ulong2 x, ulong4 mask);

ulong4 __ovld __cnfn shuffle(ulong4 x, ulong4 mask);

ulong4 __ovld __cnfn shuffle(ulong8 x, ulong4 mask);

ulong4 __ovld __cnfn shuffle(ulong16 x, ulong4 mask);


float4 __ovld __cnfn shuffle(float2 x, uint4 mask);

float4 __ovld __cnfn shuffle(float4 x, uint4 mask);

float4 __ovld __cnfn shuffle(float8 x, uint4 mask);

float4 __ovld __cnfn shuffle(float16 x, uint4 mask);


char8 __ovld __cnfn shuffle(char2 x, uchar8 mask);

char8 __ovld __cnfn shuffle(char4 x, uchar8 mask);

char8 __ovld __cnfn shuffle(char8 x, uchar8 mask);

char8 __ovld __cnfn shuffle(char16 x, uchar8 mask);


uchar8 __ovld __cnfn shuffle(uchar2 x, uchar8 mask);

uchar8 __ovld __cnfn shuffle(uchar4 x, uchar8 mask);

uchar8 __ovld __cnfn shuffle(uchar8 x, uchar8 mask);

uchar8 __ovld __cnfn shuffle(uchar16 x, uchar8 mask);


short8 __ovld __cnfn shuffle(short2 x, ushort8 mask);

short8 __ovld __cnfn shuffle(short4 x, ushort8 mask);

short8 __ovld __cnfn shuffle(short8 x, ushort8 mask);

short8 __ovld __cnfn shuffle(short16 x, ushort8 mask);


ushort8 __ovld __cnfn shuffle(ushort2 x, ushort8 mask);

ushort8 __ovld __cnfn shuffle(ushort4 x, ushort8 mask);

ushort8 __ovld __cnfn shuffle(ushort8 x, ushort8 mask);

ushort8 __ovld __cnfn shuffle(ushort16 x, ushort8 mask);


int8 __ovld __cnfn shuffle(int2 x, uint8 mask);

int8 __ovld __cnfn shuffle(int4 x, uint8 mask);

int8 __ovld __cnfn shuffle(int8 x, uint8 mask);

int8 __ovld __cnfn shuffle(int16 x, uint8 mask);


uint8 __ovld __cnfn shuffle(uint2 x, uint8 mask);

uint8 __ovld __cnfn shuffle(uint4 x, uint8 mask);

uint8 __ovld __cnfn shuffle(uint8 x, uint8 mask);

uint8 __ovld __cnfn shuffle(uint16 x, uint8 mask);


long8 __ovld __cnfn shuffle(long2 x, ulong8 mask);

long8 __ovld __cnfn shuffle(long4 x, ulong8 mask);

long8 __ovld __cnfn shuffle(long8 x, ulong8 mask);

long8 __ovld __cnfn shuffle(long16 x, ulong8 mask);


ulong8 __ovld __cnfn shuffle(ulong2 x, ulong8 mask);

ulong8 __ovld __cnfn shuffle(ulong4 x, ulong8 mask);

ulong8 __ovld __cnfn shuffle(ulong8 x, ulong8 mask);

ulong8 __ovld __cnfn shuffle(ulong16 x, ulong8 mask);


float8 __ovld __cnfn shuffle(float2 x, uint8 mask);

float8 __ovld __cnfn shuffle(float4 x, uint8 mask);

float8 __ovld __cnfn shuffle(float8 x, uint8 mask);

float8 __ovld __cnfn shuffle(float16 x, uint8 mask);


char16 __ovld __cnfn shuffle(char2 x, uchar16 mask);

char16 __ovld __cnfn shuffle(char4 x, uchar16 mask);

char16 __ovld __cnfn shuffle(char8 x, uchar16 mask);

char16 __ovld __cnfn shuffle(char16 x, uchar16 mask);


uchar16 __ovld __cnfn shuffle(uchar2 x, uchar16 mask);

uchar16 __ovld __cnfn shuffle(uchar4 x, uchar16 mask);

uchar16 __ovld __cnfn shuffle(uchar8 x, uchar16 mask);

uchar16 __ovld __cnfn shuffle(uchar16 x, uchar16 mask);


short16 __ovld __cnfn shuffle(short2 x, ushort16 mask);

short16 __ovld __cnfn shuffle(short4 x, ushort16 mask);

short16 __ovld __cnfn shuffle(short8 x, ushort16 mask);

short16 __ovld __cnfn shuffle(short16 x, ushort16 mask);


ushort16 __ovld __cnfn shuffle(ushort2 x, ushort16 mask);

ushort16 __ovld __cnfn shuffle(ushort4 x, ushort16 mask);

ushort16 __ovld __cnfn shuffle(ushort8 x, ushort16 mask);

ushort16 __ovld __cnfn shuffle(ushort16 x, ushort16 mask);


int16 __ovld __cnfn shuffle(int2 x, uint16 mask);

int16 __ovld __cnfn shuffle(int4 x, uint16 mask);

int16 __ovld __cnfn shuffle(int8 x, uint16 mask);

int16 __ovld __cnfn shuffle(int16 x, uint16 mask);


uint16 __ovld __cnfn shuffle(uint2 x, uint16 mask);

uint16 __ovld __cnfn shuffle(uint4 x, uint16 mask);

uint16 __ovld __cnfn shuffle(uint8 x, uint16 mask);

uint16 __ovld __cnfn shuffle(uint16 x, uint16 mask);


long16 __ovld __cnfn shuffle(long2 x, ulong16 mask);

long16 __ovld __cnfn shuffle(long4 x, ulong16 mask);

long16 __ovld __cnfn shuffle(long8 x, ulong16 mask);

long16 __ovld __cnfn shuffle(long16 x, ulong16 mask);


ulong16 __ovld __cnfn shuffle(ulong2 x, ulong16 mask);

ulong16 __ovld __cnfn shuffle(ulong4 x, ulong16 mask);

ulong16 __ovld __cnfn shuffle(ulong8 x, ulong16 mask);

ulong16 __ovld __cnfn shuffle(ulong16 x, ulong16 mask);


float16 __ovld __cnfn shuffle(float2 x, uint16 mask);

float16 __ovld __cnfn shuffle(float4 x, uint16 mask);

float16 __ovld __cnfn shuffle(float8 x, uint16 mask);

float16 __ovld __cnfn shuffle(float16 x, uint16 mask);


#ifdef cl_khr_fp64

double2 __ovld __cnfn shuffle(double2 x, ulong2 mask);

double2 __ovld __cnfn shuffle(double4 x, ulong2 mask);

double2 __ovld __cnfn shuffle(double8 x, ulong2 mask);

double2 __ovld __cnfn shuffle(double16 x, ulong2 mask);


double4 __ovld __cnfn shuffle(double2 x, ulong4 mask);

double4 __ovld __cnfn shuffle(double4 x, ulong4 mask);

double4 __ovld __cnfn shuffle(double8 x, ulong4 mask);

double4 __ovld __cnfn shuffle(double16 x, ulong4 mask);


double8 __ovld __cnfn shuffle(double2 x, ulong8 mask);

double8 __ovld __cnfn shuffle(double4 x, ulong8 mask);

double8 __ovld __cnfn shuffle(double8 x, ulong8 mask);

double8 __ovld __cnfn shuffle(double16 x, ulong8 mask);


double16 __ovld __cnfn shuffle(double2 x, ulong16 mask);

double16 __ovld __cnfn shuffle(double4 x, ulong16 mask);

double16 __ovld __cnfn shuffle(double8 x, ulong16 mask);

double16 __ovld __cnfn shuffle(double16 x, ulong16 mask);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

half2 __ovld __cnfn shuffle(half2 x, ushort2 mask);

half2 __ovld __cnfn shuffle(half4 x, ushort2 mask);

half2 __ovld __cnfn shuffle(half8 x, ushort2 mask);

half2 __ovld __cnfn shuffle(half16 x, ushort2 mask);


half4 __ovld __cnfn shuffle(half2 x, ushort4 mask);

half4 __ovld __cnfn shuffle(half4 x, ushort4 mask);

half4 __ovld __cnfn shuffle(half8 x, ushort4 mask);

half4 __ovld __cnfn shuffle(half16 x, ushort4 mask);


half8 __ovld __cnfn shuffle(half2 x, ushort8 mask);

half8 __ovld __cnfn shuffle(half4 x, ushort8 mask);

half8 __ovld __cnfn shuffle(half8 x, ushort8 mask);

half8 __ovld __cnfn shuffle(half16 x, ushort8 mask);


half16 __ovld __cnfn shuffle(half2 x, ushort16 mask);

half16 __ovld __cnfn shuffle(half4 x, ushort16 mask);

half16 __ovld __cnfn shuffle(half8 x, ushort16 mask);

half16 __ovld __cnfn shuffle(half16 x, ushort16 mask);

#endif //cl_khr_fp16


char2 __ovld __cnfn shuffle2(char2 x, char2 y, uchar2 mask);

char2 __ovld __cnfn shuffle2(char4 x, char4 y, uchar2 mask);

char2 __ovld __cnfn shuffle2(char8 x, char8 y, uchar2 mask);

char2 __ovld __cnfn shuffle2(char16 x, char16 y, uchar2 mask);


uchar2 __ovld __cnfn shuffle2(uchar2 x, uchar2 y, uchar2 mask);

uchar2 __ovld __cnfn shuffle2(uchar4 x, uchar4 y, uchar2 mask);

uchar2 __ovld __cnfn shuffle2(uchar8 x, uchar8 y, uchar2 mask);

uchar2 __ovld __cnfn shuffle2(uchar16 x, uchar16 y, uchar2 mask);


short2 __ovld __cnfn shuffle2(short2 x, short2 y, ushort2 mask);

short2 __ovld __cnfn shuffle2(short4 x, short4 y, ushort2 mask);

short2 __ovld __cnfn shuffle2(short8 x, short8 y, ushort2 mask);

short2 __ovld __cnfn shuffle2(short16 x, short16 y, ushort2 mask);


ushort2 __ovld __cnfn shuffle2(ushort2 x, ushort2 y, ushort2 mask);

ushort2 __ovld __cnfn shuffle2(ushort4 x, ushort4 y, ushort2 mask);

ushort2 __ovld __cnfn shuffle2(ushort8 x, ushort8 y, ushort2 mask);

ushort2 __ovld __cnfn shuffle2(ushort16 x, ushort16 y, ushort2 mask);


int2 __ovld __cnfn shuffle2(int2 x, int2 y, uint2 mask);

int2 __ovld __cnfn shuffle2(int4 x, int4 y, uint2 mask);

int2 __ovld __cnfn shuffle2(int8 x, int8 y, uint2 mask);

int2 __ovld __cnfn shuffle2(int16 x, int16 y, uint2 mask);


uint2 __ovld __cnfn shuffle2(uint2 x, uint2 y, uint2 mask);

uint2 __ovld __cnfn shuffle2(uint4 x, uint4 y, uint2 mask);

uint2 __ovld __cnfn shuffle2(uint8 x, uint8 y, uint2 mask);

uint2 __ovld __cnfn shuffle2(uint16 x, uint16 y, uint2 mask);


long2 __ovld __cnfn shuffle2(long2 x, long2 y, ulong2 mask);

long2 __ovld __cnfn shuffle2(long4 x, long4 y, ulong2 mask);

long2 __ovld __cnfn shuffle2(long8 x, long8 y, ulong2 mask);

long2 __ovld __cnfn shuffle2(long16 x, long16 y, ulong2 mask);


ulong2 __ovld __cnfn shuffle2(ulong2 x, ulong2 y, ulong2 mask);

ulong2 __ovld __cnfn shuffle2(ulong4 x, ulong4 y, ulong2 mask);

ulong2 __ovld __cnfn shuffle2(ulong8 x, ulong8 y, ulong2 mask);

ulong2 __ovld __cnfn shuffle2(ulong16 x, ulong16 y, ulong2 mask);


float2 __ovld __cnfn shuffle2(float2 x, float2 y, uint2 mask);

float2 __ovld __cnfn shuffle2(float4 x, float4 y, uint2 mask);

float2 __ovld __cnfn shuffle2(float8 x, float8 y, uint2 mask);

float2 __ovld __cnfn shuffle2(float16 x, float16 y, uint2 mask);


char4 __ovld __cnfn shuffle2(char2 x, char2 y, uchar4 mask);

char4 __ovld __cnfn shuffle2(char4 x, char4 y, uchar4 mask);

char4 __ovld __cnfn shuffle2(char8 x, char8 y, uchar4 mask);

char4 __ovld __cnfn shuffle2(char16 x, char16 y, uchar4 mask);


uchar4 __ovld __cnfn shuffle2(uchar2 x, uchar2 y, uchar4 mask);

uchar4 __ovld __cnfn shuffle2(uchar4 x, uchar4 y, uchar4 mask);

uchar4 __ovld __cnfn shuffle2(uchar8 x, uchar8 y, uchar4 mask);

uchar4 __ovld __cnfn shuffle2(uchar16 x, uchar16 y, uchar4 mask);


short4 __ovld __cnfn shuffle2(short2 x, short2 y, ushort4 mask);

short4 __ovld __cnfn shuffle2(short4 x, short4 y, ushort4 mask);

short4 __ovld __cnfn shuffle2(short8 x, short8 y, ushort4 mask);

short4 __ovld __cnfn shuffle2(short16 x, short16 y, ushort4 mask);


ushort4 __ovld __cnfn shuffle2(ushort2 x, ushort2 y, ushort4 mask);

ushort4 __ovld __cnfn shuffle2(ushort4 x, ushort4 y, ushort4 mask);

ushort4 __ovld __cnfn shuffle2(ushort8 x, ushort8 y, ushort4 mask);

ushort4 __ovld __cnfn shuffle2(ushort16 x, ushort16 y, ushort4 mask);


int4 __ovld __cnfn shuffle2(int2 x, int2 y, uint4 mask);

int4 __ovld __cnfn shuffle2(int4 x, int4 y, uint4 mask);

int4 __ovld __cnfn shuffle2(int8 x, int8 y, uint4 mask);

int4 __ovld __cnfn shuffle2(int16 x, int16 y, uint4 mask);


uint4 __ovld __cnfn shuffle2(uint2 x, uint2 y, uint4 mask);

uint4 __ovld __cnfn shuffle2(uint4 x, uint4 y, uint4 mask);

uint4 __ovld __cnfn shuffle2(uint8 x, uint8 y, uint4 mask);

uint4 __ovld __cnfn shuffle2(uint16 x, uint16 y, uint4 mask);


long4 __ovld __cnfn shuffle2(long2 x, long2 y, ulong4 mask);

long4 __ovld __cnfn shuffle2(long4 x, long4 y, ulong4 mask);

long4 __ovld __cnfn shuffle2(long8 x, long8 y, ulong4 mask);

long4 __ovld __cnfn shuffle2(long16 x, long16 y, ulong4 mask);


ulong4 __ovld __cnfn shuffle2(ulong2 x, ulong2 y, ulong4 mask);

ulong4 __ovld __cnfn shuffle2(ulong4 x, ulong4 y, ulong4 mask);

ulong4 __ovld __cnfn shuffle2(ulong8 x, ulong8 y, ulong4 mask);

ulong4 __ovld __cnfn shuffle2(ulong16 x, ulong16 y, ulong4 mask);


float4 __ovld __cnfn shuffle2(float2 x, float2 y, uint4 mask);

float4 __ovld __cnfn shuffle2(float4 x, float4 y, uint4 mask);

float4 __ovld __cnfn shuffle2(float8 x, float8 y, uint4 mask);

float4 __ovld __cnfn shuffle2(float16 x, float16 y, uint4 mask);


char8 __ovld __cnfn shuffle2(char2 x, char2 y, uchar8 mask);

char8 __ovld __cnfn shuffle2(char4 x, char4 y, uchar8 mask);

char8 __ovld __cnfn shuffle2(char8 x, char8 y, uchar8 mask);

char8 __ovld __cnfn shuffle2(char16 x, char16 y, uchar8 mask);


uchar8 __ovld __cnfn shuffle2(uchar2 x, uchar2 y, uchar8 mask);

uchar8 __ovld __cnfn shuffle2(uchar4 x, uchar4 y, uchar8 mask);

uchar8 __ovld __cnfn shuffle2(uchar8 x, uchar8 y, uchar8 mask);

uchar8 __ovld __cnfn shuffle2(uchar16 x, uchar16 y, uchar8 mask);


short8 __ovld __cnfn shuffle2(short2 x, short2 y, ushort8 mask);

short8 __ovld __cnfn shuffle2(short4 x, short4 y, ushort8 mask);

short8 __ovld __cnfn shuffle2(short8 x, short8 y, ushort8 mask);

short8 __ovld __cnfn shuffle2(short16 x, short16 y, ushort8 mask);


ushort8 __ovld __cnfn shuffle2(ushort2 x, ushort2 y, ushort8 mask);

ushort8 __ovld __cnfn shuffle2(ushort4 x, ushort4 y, ushort8 mask);

ushort8 __ovld __cnfn shuffle2(ushort8 x, ushort8 y, ushort8 mask);

ushort8 __ovld __cnfn shuffle2(ushort16 x, ushort16 y, ushort8 mask);


int8 __ovld __cnfn shuffle2(int2 x, int2 y, uint8 mask);

int8 __ovld __cnfn shuffle2(int4 x, int4 y, uint8 mask);

int8 __ovld __cnfn shuffle2(int8 x, int8 y, uint8 mask);

int8 __ovld __cnfn shuffle2(int16 x, int16 y, uint8 mask);


uint8 __ovld __cnfn shuffle2(uint2 x, uint2 y, uint8 mask);

uint8 __ovld __cnfn shuffle2(uint4 x, uint4 y, uint8 mask);

uint8 __ovld __cnfn shuffle2(uint8 x, uint8 y, uint8 mask);

uint8 __ovld __cnfn shuffle2(uint16 x, uint16 y, uint8 mask);


long8 __ovld __cnfn shuffle2(long2 x, long2 y, ulong8 mask);

long8 __ovld __cnfn shuffle2(long4 x, long4 y, ulong8 mask);

long8 __ovld __cnfn shuffle2(long8 x, long8 y, ulong8 mask);

long8 __ovld __cnfn shuffle2(long16 x, long16 y, ulong8 mask);


ulong8 __ovld __cnfn shuffle2(ulong2 x, ulong2 y, ulong8 mask);

ulong8 __ovld __cnfn shuffle2(ulong4 x, ulong4 y, ulong8 mask);

ulong8 __ovld __cnfn shuffle2(ulong8 x, ulong8 y, ulong8 mask);

ulong8 __ovld __cnfn shuffle2(ulong16 x, ulong16 y, ulong8 mask);


float8 __ovld __cnfn shuffle2(float2 x, float2 y, uint8 mask);

float8 __ovld __cnfn shuffle2(float4 x, float4 y, uint8 mask);

float8 __ovld __cnfn shuffle2(float8 x, float8 y, uint8 mask);

float8 __ovld __cnfn shuffle2(float16 x, float16 y, uint8 mask);


char16 __ovld __cnfn shuffle2(char2 x, char2 y, uchar16 mask);

char16 __ovld __cnfn shuffle2(char4 x, char4 y, uchar16 mask);

char16 __ovld __cnfn shuffle2(char8 x, char8 y, uchar16 mask);

char16 __ovld __cnfn shuffle2(char16 x, char16 y, uchar16 mask);


uchar16 __ovld __cnfn shuffle2(uchar2 x, uchar2 y, uchar16 mask);

uchar16 __ovld __cnfn shuffle2(uchar4 x, uchar4 y, uchar16 mask);

uchar16 __ovld __cnfn shuffle2(uchar8 x, uchar8 y, uchar16 mask);

uchar16 __ovld __cnfn shuffle2(uchar16 x, uchar16 y, uchar16 mask);


short16 __ovld __cnfn shuffle2(short2 x, short2 y, ushort16 mask);

short16 __ovld __cnfn shuffle2(short4 x, short4 y, ushort16 mask);

short16 __ovld __cnfn shuffle2(short8 x, short8 y, ushort16 mask);

short16 __ovld __cnfn shuffle2(short16 x, short16 y, ushort16 mask);


ushort16 __ovld __cnfn shuffle2(ushort2 x, ushort2 y, ushort16 mask);

ushort16 __ovld __cnfn shuffle2(ushort4 x, ushort4 y, ushort16 mask);

ushort16 __ovld __cnfn shuffle2(ushort8 x, ushort8 y, ushort16 mask);

ushort16 __ovld __cnfn shuffle2(ushort16 x, ushort16 y, ushort16 mask);


int16 __ovld __cnfn shuffle2(int2 x, int2 y, uint16 mask);

int16 __ovld __cnfn shuffle2(int4 x, int4 y, uint16 mask);

int16 __ovld __cnfn shuffle2(int8 x, int8 y, uint16 mask);

int16 __ovld __cnfn shuffle2(int16 x, int16 y, uint16 mask);


uint16 __ovld __cnfn shuffle2(uint2 x, uint2 y, uint16 mask);

uint16 __ovld __cnfn shuffle2(uint4 x, uint4 y, uint16 mask);

uint16 __ovld __cnfn shuffle2(uint8 x, uint8 y, uint16 mask);

uint16 __ovld __cnfn shuffle2(uint16 x, uint16 y, uint16 mask);


long16 __ovld __cnfn shuffle2(long2 x, long2 y, ulong16 mask);

long16 __ovld __cnfn shuffle2(long4 x, long4 y, ulong16 mask);

long16 __ovld __cnfn shuffle2(long8 x, long8 y, ulong16 mask);

long16 __ovld __cnfn shuffle2(long16 x, long16 y, ulong16 mask);


ulong16 __ovld __cnfn shuffle2(ulong2 x, ulong2 y, ulong16 mask);

ulong16 __ovld __cnfn shuffle2(ulong4 x, ulong4 y, ulong16 mask);

ulong16 __ovld __cnfn shuffle2(ulong8 x, ulong8 y, ulong16 mask);

ulong16 __ovld __cnfn shuffle2(ulong16 x, ulong16 y, ulong16 mask);


float16 __ovld __cnfn shuffle2(float2 x, float2 y, uint16 mask);

float16 __ovld __cnfn shuffle2(float4 x, float4 y, uint16 mask);

float16 __ovld __cnfn shuffle2(float8 x, float8 y, uint16 mask);

float16 __ovld __cnfn shuffle2(float16 x, float16 y, uint16 mask);


#ifdef cl_khr_fp64

double2 __ovld __cnfn shuffle2(double2 x, double2 y, ulong2 mask);

double2 __ovld __cnfn shuffle2(double4 x, double4 y, ulong2 mask);

double2 __ovld __cnfn shuffle2(double8 x, double8 y, ulong2 mask);

double2 __ovld __cnfn shuffle2(double16 x, double16 y, ulong2 mask);


double4 __ovld __cnfn shuffle2(double2 x, double2 y, ulong4 mask);

double4 __ovld __cnfn shuffle2(double4 x, double4 y, ulong4 mask);

double4 __ovld __cnfn shuffle2(double8 x, double8 y, ulong4 mask);

double4 __ovld __cnfn shuffle2(double16 x, double16 y, ulong4 mask);


double8 __ovld __cnfn shuffle2(double2 x, double2 y, ulong8 mask);

double8 __ovld __cnfn shuffle2(double4 x, double4 y, ulong8 mask);

double8 __ovld __cnfn shuffle2(double8 x, double8 y, ulong8 mask);

double8 __ovld __cnfn shuffle2(double16 x, double16 y, ulong8 mask);


double16 __ovld __cnfn shuffle2(double2 x, double2 y, ulong16 mask);

double16 __ovld __cnfn shuffle2(double4 x, double4 y, ulong16 mask);

double16 __ovld __cnfn shuffle2(double8 x, double8 y, ulong16 mask);

double16 __ovld __cnfn shuffle2(double16 x, double16 y, ulong16 mask);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

half2 __ovld __cnfn shuffle2(half2 x, half2 y, ushort2 mask);

half2 __ovld __cnfn shuffle2(half4 x, half4 y, ushort2 mask);

half2 __ovld __cnfn shuffle2(half8 x, half8 y, ushort2 mask);

half2 __ovld __cnfn shuffle2(half16 x, half16 y, ushort2 mask);


half4 __ovld __cnfn shuffle2(half2 x, half2 y, ushort4 mask);

half4 __ovld __cnfn shuffle2(half4 x, half4 y, ushort4 mask);

half4 __ovld __cnfn shuffle2(half8 x, half8 y, ushort4 mask);

half4 __ovld __cnfn shuffle2(half16 x, half16 y, ushort4 mask);


half8 __ovld __cnfn shuffle2(half2 x, half2 y, ushort8 mask);

half8 __ovld __cnfn shuffle2(half4 x, half4 y, ushort8 mask);

half8 __ovld __cnfn shuffle2(half8 x, half8 y, ushort8 mask);

half8 __ovld __cnfn shuffle2(half16 x, half16 y, ushort8 mask);


half16 __ovld __cnfn shuffle2(half2 x, half2 y, ushort16 mask);

half16 __ovld __cnfn shuffle2(half4 x, half4 y, ushort16 mask);

half16 __ovld __cnfn shuffle2(half8 x, half8 y, ushort16 mask);

half16 __ovld __cnfn shuffle2(half16 x, half16 y, ushort16 mask);

#endif //cl_khr_fp16


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)

// OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf


int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)));

#endif


// OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions


#ifdef cl_khr_gl_msaa_sharing

#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable

#endif //cl_khr_gl_msaa_sharing


float4 __purefn __ovld read_imagef(read_only image2d_t image, sampler_t sampler, int2 coord);

float4 __purefn __ovld read_imagef(read_only image2d_t image, sampler_t sampler, float2 coord);


int4 __purefn __ovld read_imagei(read_only image2d_t image, sampler_t sampler, int2 coord);

int4 __purefn __ovld read_imagei(read_only image2d_t image, sampler_t sampler, float2 coord);

uint4 __purefn __ovld read_imageui(read_only image2d_t image, sampler_t sampler, int2 coord);

uint4 __purefn __ovld read_imageui(read_only image2d_t image, sampler_t sampler, float2 coord);


float4 __purefn __ovld read_imagef(read_only image3d_t image, sampler_t sampler, int4 coord);

float4 __purefn __ovld read_imagef(read_only image3d_t image, sampler_t sampler, float4 coord);


int4 __purefn __ovld read_imagei(read_only image3d_t image, sampler_t sampler, int4 coord);

int4 __purefn __ovld read_imagei(read_only image3d_t image, sampler_t sampler, float4 coord);

uint4 __purefn __ovld read_imageui(read_only image3d_t image, sampler_t sampler, int4 coord);

uint4 __purefn __ovld read_imageui(read_only image3d_t image, sampler_t sampler, float4 coord);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)

float4 __purefn __ovld read_imagef(read_only image2d_array_t image_array, sampler_t sampler, int4 coord);

float4 __purefn __ovld read_imagef(read_only image2d_array_t image_array, sampler_t sampler, float4 coord);


int4 __purefn __ovld read_imagei(read_only image2d_array_t image_array, sampler_t sampler, int4 coord);

int4 __purefn __ovld read_imagei(read_only image2d_array_t image_array, sampler_t sampler, float4 coord);

uint4 __purefn __ovld read_imageui(read_only image2d_array_t image_array, sampler_t sampler, int4 coord);

uint4 __purefn __ovld read_imageui(read_only image2d_array_t image_array, sampler_t sampler, float4 coord);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)


float4 __purefn __ovld read_imagef(read_only image1d_t image, sampler_t sampler, int coord);

float4 __purefn __ovld read_imagef(read_only image1d_t image, sampler_t sampler, float coord);


int4 __purefn __ovld read_imagei(read_only image1d_t image, sampler_t sampler, int coord);

int4 __purefn __ovld read_imagei(read_only image1d_t image, sampler_t sampler, float coord);

uint4 __purefn __ovld read_imageui(read_only image1d_t image, sampler_t sampler, int coord);

uint4 __purefn __ovld read_imageui(read_only image1d_t image, sampler_t sampler, float coord);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)

float4 __purefn __ovld read_imagef(read_only image1d_array_t image_array, sampler_t sampler, int2 coord);

float4 __purefn __ovld read_imagef(read_only image1d_array_t image_array, sampler_t sampler, float2 coord);


int4 __purefn __ovld read_imagei(read_only image1d_array_t image_array, sampler_t sampler, int2 coord);

int4 __purefn __ovld read_imagei(read_only image1d_array_t image_array, sampler_t sampler, float2 coord);

uint4 __purefn __ovld read_imageui(read_only image1d_array_t image_array, sampler_t sampler, int2 coord);

uint4 __purefn __ovld read_imageui(read_only image1d_array_t image_array, sampler_t sampler, float2 coord);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)


#ifdef cl_khr_depth_images

float __purefn __ovld read_imagef(read_only image2d_depth_t image, sampler_t sampler, float2 coord);

float __purefn __ovld read_imagef(read_only image2d_depth_t image, sampler_t sampler, int2 coord);


float __purefn __ovld read_imagef(read_only image2d_array_depth_t image, sampler_t sampler, float4 coord);

float __purefn __ovld read_imagef(read_only image2d_array_depth_t image, sampler_t sampler, int4 coord);

#endif //cl_khr_depth_images


#if defined(cl_khr_gl_msaa_sharing)

float4 __purefn __ovld read_imagef(read_only image2d_msaa_t image, int2 coord, int sample);

int4 __purefn __ovld read_imagei(read_only image2d_msaa_t image, int2 coord, int sample);

uint4 __purefn __ovld read_imageui(read_only image2d_msaa_t image, int2 coord, int sample);


float __purefn __ovld read_imagef(read_only image2d_msaa_depth_t image, int2 coord, int sample);


float4 __purefn __ovld read_imagef(read_only image2d_array_msaa_t image, int4 coord, int sample);

int4 __purefn __ovld read_imagei(read_only image2d_array_msaa_t image, int4 coord, int sample);

uint4 __purefn __ovld read_imageui(read_only image2d_array_msaa_t image, int4 coord, int sample);


float __purefn __ovld read_imagef(read_only image2d_array_msaa_depth_t image, int4 coord, int sample);

#endif //cl_khr_gl_msaa_sharing


// OpenCL Extension v2.0 s9.18 - Mipmaps

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

#ifdef cl_khr_mipmap_image


float4 __purefn __ovld read_imagef(read_only image1d_t image, sampler_t sampler, float coord, float lod);

int4 __purefn __ovld read_imagei(read_only image1d_t image, sampler_t sampler, float coord, float lod);

uint4 __purefn __ovld read_imageui(read_only image1d_t image, sampler_t sampler, float coord, float lod);


float4 __purefn __ovld read_imagef(read_only image1d_array_t image_array, sampler_t sampler, float2 coord, float lod);

int4 __purefn __ovld read_imagei(read_only image1d_array_t image_array, sampler_t sampler, float2 coord, float lod);

uint4 __purefn __ovld read_imageui(read_only image1d_array_t image_array, sampler_t sampler, float2 coord, float lod);


float4 __purefn __ovld read_imagef(read_only image2d_t image, sampler_t sampler, float2 coord, float lod);

int4 __purefn __ovld read_imagei(read_only image2d_t image, sampler_t sampler, float2 coord, float lod);

uint4 __purefn __ovld read_imageui(read_only image2d_t image, sampler_t sampler, float2 coord, float lod);


float __purefn __ovld read_imagef(read_only image2d_depth_t image, sampler_t sampler, float2 coord, float lod);


float4 __purefn __ovld read_imagef(read_only image2d_array_t image_array, sampler_t sampler, float4 coord, float lod);

int4 __purefn __ovld read_imagei(read_only image2d_array_t image_array, sampler_t sampler, float4 coord, float lod);

uint4 __purefn __ovld read_imageui(read_only image2d_array_t image_array, sampler_t sampler, float4 coord, float lod);


float __purefn __ovld read_imagef(read_only image2d_array_depth_t image, sampler_t sampler, float4 coord, float lod);


float4 __purefn __ovld read_imagef(read_only image3d_t image, sampler_t sampler, float4 coord, float lod);

int4 __purefn __ovld read_imagei(read_only image3d_t image, sampler_t sampler, float4 coord, float lod);

uint4 __purefn __ovld read_imageui(read_only image3d_t image, sampler_t sampler, float4 coord, float lod);


float4 __purefn __ovld read_imagef(read_only image1d_t image, sampler_t sampler, float coord, float gradientX, float gradientY);

int4 __purefn __ovld read_imagei(read_only image1d_t image, sampler_t sampler, float coord, float gradientX, float gradientY);

uint4 __purefn __ovld read_imageui(read_only image1d_t image, sampler_t sampler, float coord, float gradientX, float gradientY);


float4 __purefn __ovld read_imagef(read_only image1d_array_t image_array, sampler_t sampler, float2 coord, float gradientX, float gradientY);

int4 __purefn __ovld read_imagei(read_only image1d_array_t image_array, sampler_t sampler, float2 coord, float gradientX, float gradientY);

uint4 __purefn __ovld read_imageui(read_only image1d_array_t image_array, sampler_t sampler, float2 coord, float gradientX, float gradientY);


float4 __purefn __ovld read_imagef(read_only image2d_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);

int4 __purefn __ovld read_imagei(read_only image2d_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);

uint4 __purefn __ovld read_imageui(read_only image2d_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);


float __purefn __ovld read_imagef(read_only image2d_depth_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);


float4 __purefn __ovld read_imagef(read_only image2d_array_t image_array, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);

int4 __purefn __ovld read_imagei(read_only image2d_array_t image_array, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);

uint4 __purefn __ovld read_imageui(read_only image2d_array_t image_array, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);


float __purefn __ovld read_imagef(read_only image2d_array_depth_t image, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);


float4 __purefn __ovld read_imagef(read_only image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);

int4 __purefn __ovld read_imagei(read_only image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);

uint4 __purefn __ovld read_imageui(read_only image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);


#endif //cl_khr_mipmap_image

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)


float4 __purefn __ovld read_imagef(read_only image1d_t image, int coord);

int4 __purefn __ovld read_imagei(read_only image1d_t image, int coord);

uint4 __purefn __ovld read_imageui(read_only image1d_t image, int coord);


float4 __purefn __ovld read_imagef(read_only image1d_buffer_t image, int coord);

int4 __purefn __ovld read_imagei(read_only image1d_buffer_t image, int coord);

uint4 __purefn __ovld read_imageui(read_only image1d_buffer_t image, int coord);


float4 __purefn __ovld read_imagef(read_only image1d_array_t image, int2 coord);

int4 __purefn __ovld read_imagei(read_only image1d_array_t image, int2 coord);

uint4 __purefn __ovld read_imageui(read_only image1d_array_t image, int2 coord);


float4 __purefn __ovld read_imagef(read_only image2d_t image, int2 coord);

int4 __purefn __ovld read_imagei(read_only image2d_t image, int2 coord);

uint4 __purefn __ovld read_imageui(read_only image2d_t image, int2 coord);


float4 __purefn __ovld read_imagef(read_only image2d_array_t image, int4 coord);

int4 __purefn __ovld read_imagei(read_only image2d_array_t image, int4 coord);

uint4 __purefn __ovld read_imageui(read_only image2d_array_t image, int4 coord);


#ifdef cl_khr_depth_images

float __purefn __ovld read_imagef(read_only image2d_depth_t image, int2 coord);

float __purefn __ovld read_imagef(read_only image2d_array_depth_t image, int4 coord);

#endif //cl_khr_depth_images


float4 __purefn __ovld read_imagef(read_only image3d_t image, int4 coord);

int4 __purefn __ovld read_imagei(read_only image3d_t image, int4 coord);

uint4 __purefn __ovld read_imageui(read_only image3d_t image, int4 coord);


#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)


// Image read functions returning half4 type

#ifdef cl_khr_fp16

half4 __purefn __ovld read_imageh(read_only image1d_t image, sampler_t sampler, int coord);

half4 __purefn __ovld read_imageh(read_only image1d_t image, sampler_t sampler, float coord);

half4 __purefn __ovld read_imageh(read_only image2d_t image, sampler_t sampler, int2 coord);

half4 __purefn __ovld read_imageh(read_only image2d_t image, sampler_t sampler, float2 coord);

half4 __purefn __ovld read_imageh(read_only image3d_t image, sampler_t sampler, int4 coord);

half4 __purefn __ovld read_imageh(read_only image3d_t image, sampler_t sampler, float4 coord);

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)

half4 __purefn __ovld read_imageh(read_only image1d_array_t image, sampler_t sampler, int2 coord);

half4 __purefn __ovld read_imageh(read_only image1d_array_t image, sampler_t sampler, float2 coord);

half4 __purefn __ovld read_imageh(read_only image2d_array_t image, sampler_t sampler, int4 coord);

half4 __purefn __ovld read_imageh(read_only image2d_array_t image, sampler_t sampler, float4 coord);

half4 __purefn __ovld read_imageh(read_only image1d_t image, int coord);

half4 __purefn __ovld read_imageh(read_only image2d_t image, int2 coord);

half4 __purefn __ovld read_imageh(read_only image3d_t image, int4 coord);

half4 __purefn __ovld read_imageh(read_only image1d_array_t image, int2 coord);

half4 __purefn __ovld read_imageh(read_only image2d_array_t image, int4 coord);

half4 __purefn __ovld read_imageh(read_only image1d_buffer_t image, int coord);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)

#endif //cl_khr_fp16


// Image read functions for read_write images

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

float4 __purefn __ovld read_imagef(read_write image1d_t image, int coord);

int4 __purefn __ovld read_imagei(read_write image1d_t image, int coord);

uint4 __purefn __ovld read_imageui(read_write image1d_t image, int coord);


float4 __purefn __ovld read_imagef(read_write image1d_buffer_t image, int coord);

int4 __purefn __ovld read_imagei(read_write image1d_buffer_t image, int coord);

uint4 __purefn __ovld read_imageui(read_write image1d_buffer_t image, int coord);


float4 __purefn __ovld read_imagef(read_write image1d_array_t image, int2 coord);

int4 __purefn __ovld read_imagei(read_write image1d_array_t image, int2 coord);

uint4 __purefn __ovld read_imageui(read_write image1d_array_t image, int2 coord);


float4 __purefn __ovld read_imagef(read_write image2d_t image, int2 coord);

int4 __purefn __ovld read_imagei(read_write image2d_t image, int2 coord);

uint4 __purefn __ovld read_imageui(read_write image2d_t image, int2 coord);


float4 __purefn __ovld read_imagef(read_write image2d_array_t image, int4 coord);

int4 __purefn __ovld read_imagei(read_write image2d_array_t image, int4 coord);

uint4 __purefn __ovld read_imageui(read_write image2d_array_t image, int4 coord);


float4 __purefn __ovld read_imagef(read_write image3d_t image, int4 coord);

int4 __purefn __ovld read_imagei(read_write image3d_t image, int4 coord);

uint4 __purefn __ovld read_imageui(read_write image3d_t image, int4 coord);


#ifdef cl_khr_depth_images

float __purefn __ovld read_imagef(read_write image2d_depth_t image, int2 coord);

float __purefn __ovld read_imagef(read_write image2d_array_depth_t image, int4 coord);

#endif //cl_khr_depth_images


#if cl_khr_gl_msaa_sharing

float4 __purefn __ovld read_imagef(read_write image2d_msaa_t image, int2 coord, int sample);

int4 __purefn __ovld read_imagei(read_write image2d_msaa_t image, int2 coord, int sample);

uint4 __purefn __ovld read_imageui(read_write image2d_msaa_t image, int2 coord, int sample);


float4 __purefn __ovld read_imagef(read_write image2d_array_msaa_t image, int4 coord, int sample);

int4 __purefn __ovld read_imagei(read_write image2d_array_msaa_t image, int4 coord, int sample);

uint4 __purefn __ovld read_imageui(read_write image2d_array_msaa_t image, int4 coord, int sample);


float __purefn __ovld read_imagef(read_write image2d_msaa_depth_t image, int2 coord, int sample);

float __purefn __ovld read_imagef(read_write image2d_array_msaa_depth_t image, int4 coord, int sample);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

#ifdef cl_khr_mipmap_image

float4 __purefn __ovld read_imagef(read_write image1d_t image, sampler_t sampler, float coord, float lod);

int4 __purefn __ovld read_imagei(read_write image1d_t image, sampler_t sampler, float coord, float lod);

uint4 __purefn __ovld read_imageui(read_write image1d_t image, sampler_t sampler, float coord, float lod);


float4 __purefn __ovld read_imagef(read_write image1d_array_t image_array, sampler_t sampler, float2 coord, float lod);

int4 __purefn __ovld read_imagei(read_write image1d_array_t image_array, sampler_t sampler, float2 coord, float lod);

uint4 __purefn __ovld read_imageui(read_write image1d_array_t image_array, sampler_t sampler, float2 coord, float lod);


float4 __purefn __ovld read_imagef(read_write image2d_t image, sampler_t sampler, float2 coord, float lod);

int4 __purefn __ovld read_imagei(read_write image2d_t image, sampler_t sampler, float2 coord, float lod);

uint4 __purefn __ovld read_imageui(read_write image2d_t image, sampler_t sampler, float2 coord, float lod);


float __purefn __ovld read_imagef(read_write image2d_depth_t image, sampler_t sampler, float2 coord, float lod);


float4 __purefn __ovld read_imagef(read_write image2d_array_t image_array, sampler_t sampler, float4 coord, float lod);

int4 __purefn __ovld read_imagei(read_write image2d_array_t image_array, sampler_t sampler, float4 coord, float lod);

uint4 __purefn __ovld read_imageui(read_write image2d_array_t image_array, sampler_t sampler, float4 coord, float lod);


float __purefn __ovld read_imagef(read_write image2d_array_depth_t image, sampler_t sampler, float4 coord, float lod);


float4 __purefn __ovld read_imagef(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);

int4 __purefn __ovld read_imagei(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);

uint4 __purefn __ovld read_imageui(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);


float4 __purefn __ovld read_imagef(read_write image1d_t image, sampler_t sampler, float coord, float gradientX, float gradientY);

int4 __purefn __ovld read_imagei(read_write image1d_t image, sampler_t sampler, float coord, float gradientX, float gradientY);

uint4 __purefn __ovld read_imageui(read_write image1d_t image, sampler_t sampler, float coord, float gradientX, float gradientY);


float4 __purefn __ovld read_imagef(read_write image1d_array_t image_array, sampler_t sampler, float2 coord, float gradientX, float gradientY);

int4 __purefn __ovld read_imagei(read_write image1d_array_t image_array, sampler_t sampler, float2 coord, float gradientX, float gradientY);

uint4 __purefn __ovld read_imageui(read_write image1d_array_t image_array, sampler_t sampler, float2 coord, float gradientX, float gradientY);


float4 __purefn __ovld read_imagef(read_write image2d_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);

int4 __purefn __ovld read_imagei(read_write image2d_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);

uint4 __purefn __ovld read_imageui(read_write image2d_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);


float __purefn __ovld read_imagef(read_write image2d_depth_t image, sampler_t sampler, float2 coord, float2 gradientX, float2 gradientY);


float4 __purefn __ovld read_imagef(read_write image2d_array_t image_array, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);

int4 __purefn __ovld read_imagei(read_write image2d_array_t image_array, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);

uint4 __purefn __ovld read_imageui(read_write image2d_array_t image_array, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);


float __purefn __ovld read_imagef(read_write image2d_array_depth_t image, sampler_t sampler, float4 coord, float2 gradientX, float2 gradientY);


float4 __purefn __ovld read_imagef(read_write image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);

int4 __purefn __ovld read_imagei(read_write image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);

uint4 __purefn __ovld read_imageui(read_write image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);


#endif //cl_khr_mipmap_image

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// Image read functions returning half4 type

#ifdef cl_khr_fp16

half4 __purefn __ovld read_imageh(read_write image1d_t image, int coord);

half4 __purefn __ovld read_imageh(read_write image2d_t image, int2 coord);

half4 __purefn __ovld read_imageh(read_write image3d_t image, int4 coord);

half4 __purefn __ovld read_imageh(read_write image1d_array_t image, int2 coord);

half4 __purefn __ovld read_imageh(read_write image2d_array_t image, int4 coord);

half4 __purefn __ovld read_imageh(read_write image1d_buffer_t image, int coord);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


void __ovld write_imagef(write_only image2d_t image, int2 coord, float4 color);

void __ovld write_imagei(write_only image2d_t image, int2 coord, int4 color);

void __ovld write_imageui(write_only image2d_t image, int2 coord, uint4 color);


void __ovld write_imagef(write_only image2d_array_t image_array, int4 coord, float4 color);

void __ovld write_imagei(write_only image2d_array_t image_array, int4 coord, int4 color);

void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, uint4 color);


void __ovld write_imagef(write_only image1d_t image, int coord, float4 color);

void __ovld write_imagei(write_only image1d_t image, int coord, int4 color);

void __ovld write_imageui(write_only image1d_t image, int coord, uint4 color);


void __ovld write_imagef(write_only image1d_buffer_t image, int coord, float4 color);

void __ovld write_imagei(write_only image1d_buffer_t image, int coord, int4 color);

void __ovld write_imageui(write_only image1d_buffer_t image, int coord, uint4 color);


void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, float4 color);

void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int4 color);

void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, uint4 color);


#ifdef cl_khr_3d_image_writes

void __ovld write_imagef(write_only image3d_t image, int4 coord, float4 color);

void __ovld write_imagei(write_only image3d_t image, int4 coord, int4 color);

void __ovld write_imageui(write_only image3d_t image, int4 coord, uint4 color);

#endif


#ifdef cl_khr_depth_images

void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, float color);

void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, float color);

#endif //cl_khr_depth_images


// OpenCL Extension v2.0 s9.18 - Mipmaps

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

#if defined(cl_khr_mipmap_image_writes)

void __ovld write_imagef(write_only image1d_t image, int coord, int lod, float4 color);

void __ovld write_imagei(write_only image1d_t image, int coord, int lod, int4 color);

void __ovld write_imageui(write_only image1d_t image, int coord, int lod, uint4 color);


void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, int lod, float4 color);

void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int lod, int4 color);

void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, int lod, uint4 color);


void __ovld write_imagef(write_only image2d_t image, int2 coord, int lod, float4 color);

void __ovld write_imagei(write_only image2d_t image, int2 coord, int lod, int4 color);

void __ovld write_imageui(write_only image2d_t image, int2 coord, int lod, uint4 color);


void __ovld write_imagef(write_only image2d_array_t image_array, int4 coord, int lod, float4 color);

void __ovld write_imagei(write_only image2d_array_t image_array, int4 coord, int lod, int4 color);

void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, int lod, uint4 color);


void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, int lod, float depth);

void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, int lod, float depth);


#ifdef cl_khr_3d_image_writes

void __ovld write_imagef(write_only image3d_t image, int4 coord, int lod, float4 color);

void __ovld write_imagei(write_only image3d_t image, int4 coord, int lod, int4 color);

void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4 color);

#endif //cl_khr_3d_image_writes


#endif //defined(cl_khr_mipmap_image_writes)

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// Image write functions for half4 type

#ifdef cl_khr_fp16

void __ovld write_imageh(write_only image1d_t image, int coord, half4 color);

void __ovld write_imageh(write_only image2d_t image, int2 coord, half4 color);

#ifdef cl_khr_3d_image_writes

void __ovld write_imageh(write_only image3d_t image, int4 coord, half4 color);

#endif

void __ovld write_imageh(write_only image1d_array_t image, int2 coord, half4 color);

void __ovld write_imageh(write_only image2d_array_t image, int4 coord, half4 color);

void __ovld write_imageh(write_only image1d_buffer_t image, int coord, half4 color);

#endif //cl_khr_fp16


// Image write functions for read_write images

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __ovld write_imagef(read_write image2d_t image, int2 coord, float4 color);

void __ovld write_imagei(read_write image2d_t image, int2 coord, int4 color);

void __ovld write_imageui(read_write image2d_t image, int2 coord, uint4 color);


void __ovld write_imagef(read_write image2d_array_t image_array, int4 coord, float4 color);

void __ovld write_imagei(read_write image2d_array_t image_array, int4 coord, int4 color);

void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, uint4 color);


void __ovld write_imagef(read_write image1d_t image, int coord, float4 color);

void __ovld write_imagei(read_write image1d_t image, int coord, int4 color);

void __ovld write_imageui(read_write image1d_t image, int coord, uint4 color);


void __ovld write_imagef(read_write image1d_buffer_t image, int coord, float4 color);

void __ovld write_imagei(read_write image1d_buffer_t image, int coord, int4 color);

void __ovld write_imageui(read_write image1d_buffer_t image, int coord, uint4 color);


void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, float4 color);

void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int4 color);

void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, uint4 color);


#ifdef cl_khr_3d_image_writes

void __ovld write_imagef(read_write image3d_t image, int4 coord, float4 color);

void __ovld write_imagei(read_write image3d_t image, int4 coord, int4 color);

void __ovld write_imageui(read_write image3d_t image, int4 coord, uint4 color);

#endif


#ifdef cl_khr_depth_images

void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, float color);

void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, float color);

#endif //cl_khr_depth_images


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

#if defined(cl_khr_mipmap_image_writes)

void __ovld write_imagef(read_write image1d_t image, int coord, int lod, float4 color);

void __ovld write_imagei(read_write image1d_t image, int coord, int lod, int4 color);

void __ovld write_imageui(read_write image1d_t image, int coord, int lod, uint4 color);


void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, int lod, float4 color);

void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int lod, int4 color);

void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, int lod, uint4 color);


void __ovld write_imagef(read_write image2d_t image, int2 coord, int lod, float4 color);

void __ovld write_imagei(read_write image2d_t image, int2 coord, int lod, int4 color);

void __ovld write_imageui(read_write image2d_t image, int2 coord, int lod, uint4 color);


void __ovld write_imagef(read_write image2d_array_t image_array, int4 coord, int lod, float4 color);

void __ovld write_imagei(read_write image2d_array_t image_array, int4 coord, int lod, int4 color);

void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, int lod, uint4 color);


void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, int lod, float color);

void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, int lod, float color);


#ifdef cl_khr_3d_image_writes

void __ovld write_imagef(read_write image3d_t image, int4 coord, int lod, float4 color);

void __ovld write_imagei(read_write image3d_t image, int4 coord, int lod, int4 color);

void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4 color);

#endif //cl_khr_3d_image_writes


#endif //cl_khr_mipmap_image_writes

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// Image write functions for half4 type

#ifdef cl_khr_fp16

void __ovld write_imageh(read_write image1d_t image, int coord, half4 color);

void __ovld write_imageh(read_write image2d_t image, int2 coord, half4 color);

#ifdef cl_khr_3d_image_writes

void __ovld write_imageh(read_write image3d_t image, int4 coord, half4 color);

#endif

void __ovld write_imageh(read_write image1d_array_t image, int2 coord, half4 color);

void __ovld write_imageh(read_write image2d_array_t image, int4 coord, half4 color);

void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 color);

#endif //cl_khr_fp16

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// Note: In OpenCL v1.0/1.1/1.2, image argument of image query builtin functions does not have

// access qualifier, which by default assume read_only access qualifier. Image query builtin

// functions with write_only image argument should also be declared.


int __ovld __cnfn get_image_width(read_only image1d_t image);

int __ovld __cnfn get_image_width(read_only image1d_buffer_t image);

int __ovld __cnfn get_image_width(read_only image2d_t image);

#ifdef cl_khr_3d_image_writes

int __ovld __cnfn get_image_width(read_only image3d_t image);

#endif

int __ovld __cnfn get_image_width(read_only image1d_array_t image);

int __ovld __cnfn get_image_width(read_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_width(read_only image2d_depth_t image);

int __ovld __cnfn get_image_width(read_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_width(read_only image2d_msaa_t image);

int __ovld __cnfn get_image_width(read_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_width(read_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


int __ovld __cnfn get_image_width(write_only image1d_t image);

int __ovld __cnfn get_image_width(write_only image1d_buffer_t image);

int __ovld __cnfn get_image_width(write_only image2d_t image);

#ifdef cl_khr_3d_image_writes

int __ovld __cnfn get_image_width(write_only image3d_t image);

#endif

int __ovld __cnfn get_image_width(write_only image1d_array_t image);

int __ovld __cnfn get_image_width(write_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_width(write_only image2d_depth_t image);

int __ovld __cnfn get_image_width(write_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_width(write_only image2d_msaa_t image);

int __ovld __cnfn get_image_width(write_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_width(write_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_width(write_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld __cnfn get_image_width(read_write image1d_t image);

int __ovld __cnfn get_image_width(read_write image1d_buffer_t image);

int __ovld __cnfn get_image_width(read_write image2d_t image);

int __ovld __cnfn get_image_width(read_write image3d_t image);

int __ovld __cnfn get_image_width(read_write image1d_array_t image);

int __ovld __cnfn get_image_width(read_write image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_width(read_write image2d_depth_t image);

int __ovld __cnfn get_image_width(read_write image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_width(read_write image2d_msaa_t image);

int __ovld __cnfn get_image_width(read_write image2d_msaa_depth_t image);

int __ovld __cnfn get_image_width(read_write image2d_array_msaa_t image);

int __ovld __cnfn get_image_width(read_write image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int __ovld __cnfn get_image_height(read_only image2d_t image);

int __ovld __cnfn get_image_height(read_only image3d_t image);

int __ovld __cnfn get_image_height(read_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_height(read_only image2d_depth_t image);

int __ovld __cnfn get_image_height(read_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_height(read_only image2d_msaa_t image);

int __ovld __cnfn get_image_height(read_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_height(read_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


int __ovld __cnfn get_image_height(write_only image2d_t image);

#ifdef cl_khr_3d_image_writes

int __ovld __cnfn get_image_height(write_only image3d_t image);

#endif

int __ovld __cnfn get_image_height(write_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_height(write_only image2d_depth_t image);

int __ovld __cnfn get_image_height(write_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_height(write_only image2d_msaa_t image);

int __ovld __cnfn get_image_height(write_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_height(write_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_height(write_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld __cnfn get_image_height(read_write image2d_t image);

int __ovld __cnfn get_image_height(read_write image3d_t image);

int __ovld __cnfn get_image_height(read_write image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_height(read_write image2d_depth_t image);

int __ovld __cnfn get_image_height(read_write image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_height(read_write image2d_msaa_t image);

int __ovld __cnfn get_image_height(read_write image2d_msaa_depth_t image);

int __ovld __cnfn get_image_height(read_write image2d_array_msaa_t image);

int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int __ovld __cnfn get_image_depth(read_only image3d_t image);


#ifdef cl_khr_3d_image_writes

int __ovld __cnfn get_image_depth(write_only image3d_t image);

#endif


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld __cnfn get_image_depth(read_write image3d_t image);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL Extension v2.0 s9.18 - Mipmaps

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

#ifdef cl_khr_mipmap_image

int __ovld get_image_num_mip_levels(read_only image1d_t image);

int __ovld get_image_num_mip_levels(read_only image2d_t image);

int __ovld get_image_num_mip_levels(read_only image3d_t image);


int __ovld get_image_num_mip_levels(write_only image1d_t image);

int __ovld get_image_num_mip_levels(write_only image2d_t image);

#ifdef cl_khr_3d_image_writes

int __ovld get_image_num_mip_levels(write_only image3d_t image);

#endif


int __ovld get_image_num_mip_levels(read_write image1d_t image);

int __ovld get_image_num_mip_levels(read_write image2d_t image);

int __ovld get_image_num_mip_levels(read_write image3d_t image);


int __ovld get_image_num_mip_levels(read_only image1d_array_t image);

int __ovld get_image_num_mip_levels(read_only image2d_array_t image);

int __ovld get_image_num_mip_levels(read_only image2d_array_depth_t image);

int __ovld get_image_num_mip_levels(read_only image2d_depth_t image);


int __ovld get_image_num_mip_levels(write_only image1d_array_t image);

int __ovld get_image_num_mip_levels(write_only image2d_array_t image);

int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t image);

int __ovld get_image_num_mip_levels(write_only image2d_depth_t image);


int __ovld get_image_num_mip_levels(read_write image1d_array_t image);

int __ovld get_image_num_mip_levels(read_write image2d_array_t image);

int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t image);

int __ovld get_image_num_mip_levels(read_write image2d_depth_t image);


#endif //cl_khr_mipmap_image

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int __ovld __cnfn get_image_channel_data_type(read_only image1d_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image1d_buffer_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image2d_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image3d_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image1d_array_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_channel_data_type(read_only image2d_depth_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


int __ovld __cnfn get_image_channel_data_type(write_only image1d_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image2d_t image);

#ifdef cl_khr_3d_image_writes

int __ovld __cnfn get_image_channel_data_type(write_only image3d_t image);

#endif

int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_channel_data_type(write_only image2d_depth_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld __cnfn get_image_channel_data_type(read_write image1d_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image1d_buffer_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image2d_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image3d_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image1d_array_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_channel_data_type(read_write image2d_depth_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_depth_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_t image);

int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int __ovld __cnfn get_image_channel_order(read_only image1d_t image);

int __ovld __cnfn get_image_channel_order(read_only image1d_buffer_t image);

int __ovld __cnfn get_image_channel_order(read_only image2d_t image);

int __ovld __cnfn get_image_channel_order(read_only image3d_t image);

int __ovld __cnfn get_image_channel_order(read_only image1d_array_t image);

int __ovld __cnfn get_image_channel_order(read_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_channel_order(read_only image2d_depth_t image);

int __ovld __cnfn get_image_channel_order(read_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_t image);

int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


int __ovld __cnfn get_image_channel_order(write_only image1d_t image);

int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t image);

int __ovld __cnfn get_image_channel_order(write_only image2d_t image);

#ifdef cl_khr_3d_image_writes

int __ovld __cnfn get_image_channel_order(write_only image3d_t image);

#endif

int __ovld __cnfn get_image_channel_order(write_only image1d_array_t image);

int __ovld __cnfn get_image_channel_order(write_only image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_channel_order(write_only image2d_depth_t image);

int __ovld __cnfn get_image_channel_order(write_only image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_t image);

int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_depth_t image);

int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_t image);

int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld __cnfn get_image_channel_order(read_write image1d_t image);

int __ovld __cnfn get_image_channel_order(read_write image1d_buffer_t image);

int __ovld __cnfn get_image_channel_order(read_write image2d_t image);

int __ovld __cnfn get_image_channel_order(read_write image3d_t image);

int __ovld __cnfn get_image_channel_order(read_write image1d_array_t image);

int __ovld __cnfn get_image_channel_order(read_write image2d_array_t image);

#ifdef cl_khr_depth_images

int __ovld __cnfn get_image_channel_order(read_write image2d_depth_t image);

int __ovld __cnfn get_image_channel_order(read_write image2d_array_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_t image);

int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_depth_t image);

int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_t image);

int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int2 __ovld __cnfn get_image_dim(read_only image2d_t image);

int2 __ovld __cnfn get_image_dim(read_only image2d_array_t image);

#ifdef cl_khr_depth_images

int2 __ovld __cnfn get_image_dim(read_only image2d_array_depth_t image);

int2 __ovld __cnfn get_image_dim(read_only image2d_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_t image);

int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_depth_t image);

int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_t image);

int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


int2 __ovld __cnfn get_image_dim(write_only image2d_t image);

int2 __ovld __cnfn get_image_dim(write_only image2d_array_t image);

#ifdef cl_khr_depth_images

int2 __ovld __cnfn get_image_dim(write_only image2d_array_depth_t image);

int2 __ovld __cnfn get_image_dim(write_only image2d_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_t image);

int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_depth_t image);

int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_t image);

int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int2 __ovld __cnfn get_image_dim(read_write image2d_t image);

int2 __ovld __cnfn get_image_dim(read_write image2d_array_t image);

#ifdef cl_khr_depth_images

int2 __ovld __cnfn get_image_dim(read_write image2d_array_depth_t image);

int2 __ovld __cnfn get_image_dim(read_write image2d_depth_t image);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_t image);

int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_depth_t image);

int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_t image);

int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);

#endif //cl_khr_gl_msaa_sharing

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int4 __ovld __cnfn get_image_dim(read_only image3d_t image);

#ifdef cl_khr_3d_image_writes

int4 __ovld __cnfn get_image_dim(write_only image3d_t image);

#endif

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int4 __ovld __cnfn get_image_dim(read_write image3d_t image);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


size_t __ovld __cnfn get_image_array_size(read_only image1d_array_t image_array);

size_t __ovld __cnfn get_image_array_size(read_only image2d_array_t image_array);

#ifdef cl_khr_depth_images

size_t __ovld __cnfn get_image_array_size(read_only image2d_array_depth_t image_array);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_t image_array);

size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_depth_t image_array);

#endif //cl_khr_gl_msaa_sharing


size_t __ovld __cnfn get_image_array_size(write_only image1d_array_t image_array);

size_t __ovld __cnfn get_image_array_size(write_only image2d_array_t image_array);

#ifdef cl_khr_depth_images

size_t __ovld __cnfn get_image_array_size(write_only image2d_array_depth_t image_array);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_t image_array);

size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t image_array);

#endif //cl_khr_gl_msaa_sharing


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

size_t __ovld __cnfn get_image_array_size(read_write image1d_array_t image_array);

size_t __ovld __cnfn get_image_array_size(read_write image2d_array_t image_array);

#ifdef cl_khr_depth_images

size_t __ovld __cnfn get_image_array_size(read_write image2d_array_depth_t image_array);

#endif //cl_khr_depth_images

#if defined(cl_khr_gl_msaa_sharing)

size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_t image_array);

size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_depth_t image_array);

#endif //cl_khr_gl_msaa_sharing

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


#if defined(cl_khr_gl_msaa_sharing)

int __ovld get_image_num_samples(read_only image2d_msaa_t image);

int __ovld get_image_num_samples(read_only image2d_msaa_depth_t image);

int __ovld get_image_num_samples(read_only image2d_array_msaa_t image);

int __ovld get_image_num_samples(read_only image2d_array_msaa_depth_t image);


int __ovld get_image_num_samples(write_only image2d_msaa_t image);

int __ovld get_image_num_samples(write_only image2d_msaa_depth_t image);

int __ovld get_image_num_samples(write_only image2d_array_msaa_t image);

int __ovld get_image_num_samples(write_only image2d_array_msaa_depth_t image);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld get_image_num_samples(read_write image2d_msaa_t image);

int __ovld get_image_num_samples(read_write image2d_msaa_depth_t image);

int __ovld get_image_num_samples(read_write image2d_array_msaa_t image);

int __ovld get_image_num_samples(read_write image2d_array_msaa_depth_t image);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

#endif


// OpenCL v2.0 s6.13.15 - Work-group Functions


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

int __ovld __conv work_group_all(int predicate);

int __ovld __conv work_group_any(int predicate);


#ifdef cl_khr_fp16

half __ovld __conv work_group_broadcast(half a, size_t local_id);

half __ovld __conv work_group_broadcast(half a, size_t x, size_t y);

half __ovld __conv work_group_broadcast(half a, size_t x, size_t y, size_t z);

#endif

int __ovld __conv work_group_broadcast(int a, size_t local_id);

int __ovld __conv work_group_broadcast(int a, size_t x, size_t y);

int __ovld __conv work_group_broadcast(int a, size_t x, size_t y, size_t z);

uint __ovld __conv work_group_broadcast(uint a, size_t local_id);

uint __ovld __conv work_group_broadcast(uint a, size_t x, size_t y);

uint __ovld __conv work_group_broadcast(uint a, size_t x, size_t y, size_t z);

long __ovld __conv work_group_broadcast(long a, size_t local_id);

long __ovld __conv work_group_broadcast(long a, size_t x, size_t y);

long __ovld __conv work_group_broadcast(long a, size_t x, size_t y, size_t z);

ulong __ovld __conv work_group_broadcast(ulong a, size_t local_id);

ulong __ovld __conv work_group_broadcast(ulong a, size_t x, size_t y);

ulong __ovld __conv work_group_broadcast(ulong a, size_t x, size_t y, size_t z);

float __ovld __conv work_group_broadcast(float a, size_t local_id);

float __ovld __conv work_group_broadcast(float a, size_t x, size_t y);

float __ovld __conv work_group_broadcast(float a, size_t x, size_t y, size_t z);

#ifdef cl_khr_fp64

double __ovld __conv work_group_broadcast(double a, size_t local_id);

double __ovld __conv work_group_broadcast(double a, size_t x, size_t y);

double __ovld __conv work_group_broadcast(double a, size_t x, size_t y, size_t z);

#endif //cl_khr_fp64


#ifdef cl_khr_fp16

half __ovld __conv work_group_reduce_add(half x);

half __ovld __conv work_group_reduce_min(half x);

half __ovld __conv work_group_reduce_max(half x);

half __ovld __conv work_group_scan_exclusive_add(half x);

half __ovld __conv work_group_scan_exclusive_min(half x);

half __ovld __conv work_group_scan_exclusive_max(half x);

half __ovld __conv work_group_scan_inclusive_add(half x);

half __ovld __conv work_group_scan_inclusive_min(half x);

half __ovld __conv work_group_scan_inclusive_max(half x);

#endif

int __ovld __conv work_group_reduce_add(int x);

int __ovld __conv work_group_reduce_min(int x);

int __ovld __conv work_group_reduce_max(int x);

int __ovld __conv work_group_scan_exclusive_add(int x);

int __ovld __conv work_group_scan_exclusive_min(int x);

int __ovld __conv work_group_scan_exclusive_max(int x);

int __ovld __conv work_group_scan_inclusive_add(int x);

int __ovld __conv work_group_scan_inclusive_min(int x);

int __ovld __conv work_group_scan_inclusive_max(int x);

uint __ovld __conv work_group_reduce_add(uint x);

uint __ovld __conv work_group_reduce_min(uint x);

uint __ovld __conv work_group_reduce_max(uint x);

uint __ovld __conv work_group_scan_exclusive_add(uint x);

uint __ovld __conv work_group_scan_exclusive_min(uint x);

uint __ovld __conv work_group_scan_exclusive_max(uint x);

uint __ovld __conv work_group_scan_inclusive_add(uint x);

uint __ovld __conv work_group_scan_inclusive_min(uint x);

uint __ovld __conv work_group_scan_inclusive_max(uint x);

long __ovld __conv work_group_reduce_add(long x);

long __ovld __conv work_group_reduce_min(long x);

long __ovld __conv work_group_reduce_max(long x);

long __ovld __conv work_group_scan_exclusive_add(long x);

long __ovld __conv work_group_scan_exclusive_min(long x);

long __ovld __conv work_group_scan_exclusive_max(long x);

long __ovld __conv work_group_scan_inclusive_add(long x);

long __ovld __conv work_group_scan_inclusive_min(long x);

long __ovld __conv work_group_scan_inclusive_max(long x);

ulong __ovld __conv work_group_reduce_add(ulong x);

ulong __ovld __conv work_group_reduce_min(ulong x);

ulong __ovld __conv work_group_reduce_max(ulong x);

ulong __ovld __conv work_group_scan_exclusive_add(ulong x);

ulong __ovld __conv work_group_scan_exclusive_min(ulong x);

ulong __ovld __conv work_group_scan_exclusive_max(ulong x);

ulong __ovld __conv work_group_scan_inclusive_add(ulong x);

ulong __ovld __conv work_group_scan_inclusive_min(ulong x);

ulong __ovld __conv work_group_scan_inclusive_max(ulong x);

float __ovld __conv work_group_reduce_add(float x);

float __ovld __conv work_group_reduce_min(float x);

float __ovld __conv work_group_reduce_max(float x);

float __ovld __conv work_group_scan_exclusive_add(float x);

float __ovld __conv work_group_scan_exclusive_min(float x);

float __ovld __conv work_group_scan_exclusive_max(float x);

float __ovld __conv work_group_scan_inclusive_add(float x);

float __ovld __conv work_group_scan_inclusive_min(float x);

float __ovld __conv work_group_scan_inclusive_max(float x);

#ifdef cl_khr_fp64

double __ovld __conv work_group_reduce_add(double x);

double __ovld __conv work_group_reduce_min(double x);

double __ovld __conv work_group_reduce_max(double x);

double __ovld __conv work_group_scan_exclusive_add(double x);

double __ovld __conv work_group_scan_exclusive_min(double x);

double __ovld __conv work_group_scan_exclusive_max(double x);

double __ovld __conv work_group_scan_inclusive_add(double x);

double __ovld __conv work_group_scan_inclusive_min(double x);

double __ovld __conv work_group_scan_inclusive_max(double x);

#endif //cl_khr_fp64


#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v2.0 s6.13.16 - Pipe Functions

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

bool __ovld is_valid_reserve_id(reserve_id_t reserve_id);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL v2.0 s6.13.17 - Enqueue Kernels

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


ndrange_t __ovld ndrange_1D(size_t);

ndrange_t __ovld ndrange_1D(size_t, size_t);

ndrange_t __ovld ndrange_1D(size_t, size_t, size_t);


ndrange_t __ovld ndrange_2D(const size_t[2]);

ndrange_t __ovld ndrange_2D(const size_t[2], const size_t[2]);

ndrange_t __ovld ndrange_2D(const size_t[2], const size_t[2], const size_t[2]);


ndrange_t __ovld ndrange_3D(const size_t[3]);

ndrange_t __ovld ndrange_3D(const size_t[3], const size_t[3]);

ndrange_t __ovld ndrange_3D(const size_t[3], const size_t[3], const size_t[3]);


int __ovld enqueue_marker(queue_t, uint, const clk_event_t*, clk_event_t*);


void __ovld retain_event(clk_event_t);


void __ovld release_event(clk_event_t);


clk_event_t __ovld create_user_event(void);


void __ovld set_user_event_status(clk_event_t e, int state);


bool __ovld is_valid_event (clk_event_t event);


void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void* value);


queue_t __ovld get_default_queue(void);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


// OpenCL Extension v2.0 s9.17 - Sub-groups


#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)

// Shared Sub Group Functions

uint    __ovld get_sub_group_size(void);

uint    __ovld get_max_sub_group_size(void);

uint    __ovld get_num_sub_groups(void);

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

uint    __ovld get_enqueued_num_sub_groups(void);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

uint    __ovld get_sub_group_id(void);

uint    __ovld get_sub_group_local_id(void);


void    __ovld __conv sub_group_barrier(cl_mem_fence_flags flags);

#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void    __ovld __conv sub_group_barrier(cl_mem_fence_flags flags, memory_scope scope);

#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


int     __ovld __conv sub_group_all(int predicate);

int     __ovld __conv sub_group_any(int predicate);


int     __ovld __conv sub_group_broadcast(int   x, uint sub_group_local_id);

uint    __ovld __conv sub_group_broadcast(uint  x, uint sub_group_local_id);

long    __ovld __conv sub_group_broadcast(long  x, uint sub_group_local_id);

ulong   __ovld __conv sub_group_broadcast(ulong x, uint sub_group_local_id);

float   __ovld __conv sub_group_broadcast(float x, uint sub_group_local_id);


int     __ovld __conv sub_group_reduce_add(int   x);

uint    __ovld __conv sub_group_reduce_add(uint  x);

long    __ovld __conv sub_group_reduce_add(long  x);

ulong   __ovld __conv sub_group_reduce_add(ulong x);

float   __ovld __conv sub_group_reduce_add(float x);

int     __ovld __conv sub_group_reduce_min(int   x);

uint    __ovld __conv sub_group_reduce_min(uint  x);

long    __ovld __conv sub_group_reduce_min(long  x);

ulong   __ovld __conv sub_group_reduce_min(ulong x);

float   __ovld __conv sub_group_reduce_min(float x);

int     __ovld __conv sub_group_reduce_max(int   x);

uint    __ovld __conv sub_group_reduce_max(uint  x);

long    __ovld __conv sub_group_reduce_max(long  x);

ulong   __ovld __conv sub_group_reduce_max(ulong x);

float   __ovld __conv sub_group_reduce_max(float x);


int     __ovld __conv sub_group_scan_exclusive_add(int   x);

uint    __ovld __conv sub_group_scan_exclusive_add(uint  x);

long    __ovld __conv sub_group_scan_exclusive_add(long  x);

ulong   __ovld __conv sub_group_scan_exclusive_add(ulong x);

float   __ovld __conv sub_group_scan_exclusive_add(float x);

int     __ovld __conv sub_group_scan_exclusive_min(int   x);

uint    __ovld __conv sub_group_scan_exclusive_min(uint  x);

long    __ovld __conv sub_group_scan_exclusive_min(long  x);

ulong   __ovld __conv sub_group_scan_exclusive_min(ulong x);

float   __ovld __conv sub_group_scan_exclusive_min(float x);

int     __ovld __conv sub_group_scan_exclusive_max(int   x);

uint    __ovld __conv sub_group_scan_exclusive_max(uint  x);

long    __ovld __conv sub_group_scan_exclusive_max(long  x);

ulong   __ovld __conv sub_group_scan_exclusive_max(ulong x);

float   __ovld __conv sub_group_scan_exclusive_max(float x);


int     __ovld __conv sub_group_scan_inclusive_add(int   x);

uint    __ovld __conv sub_group_scan_inclusive_add(uint  x);

long    __ovld __conv sub_group_scan_inclusive_add(long  x);

ulong   __ovld __conv sub_group_scan_inclusive_add(ulong x);

float   __ovld __conv sub_group_scan_inclusive_add(float x);

int     __ovld __conv sub_group_scan_inclusive_min(int   x);

uint    __ovld __conv sub_group_scan_inclusive_min(uint  x);

long    __ovld __conv sub_group_scan_inclusive_min(long  x);

ulong   __ovld __conv sub_group_scan_inclusive_min(ulong x);

float   __ovld __conv sub_group_scan_inclusive_min(float x);

int     __ovld __conv sub_group_scan_inclusive_max(int   x);

uint    __ovld __conv sub_group_scan_inclusive_max(uint  x);

long    __ovld __conv sub_group_scan_inclusive_max(long  x);

ulong   __ovld __conv sub_group_scan_inclusive_max(ulong x);

float   __ovld __conv sub_group_scan_inclusive_max(float x);


#ifdef cl_khr_fp16

half    __ovld __conv sub_group_broadcast(half x, uint sub_group_local_id);

half    __ovld __conv sub_group_reduce_add(half x);

half    __ovld __conv sub_group_reduce_min(half x);

half    __ovld __conv sub_group_reduce_max(half x);

half    __ovld __conv sub_group_scan_exclusive_add(half x);

half    __ovld __conv sub_group_scan_exclusive_min(half x);

half    __ovld __conv sub_group_scan_exclusive_max(half x);

half    __ovld __conv sub_group_scan_inclusive_add(half x);

half    __ovld __conv sub_group_scan_inclusive_min(half x);

half    __ovld __conv sub_group_scan_inclusive_max(half x);

#endif //cl_khr_fp16


#ifdef cl_khr_fp64

double  __ovld __conv sub_group_broadcast(double x, uint sub_group_local_id);

double  __ovld __conv sub_group_reduce_add(double x);

double  __ovld __conv sub_group_reduce_min(double x);

double  __ovld __conv sub_group_reduce_max(double x);

double  __ovld __conv sub_group_scan_exclusive_add(double x);

double  __ovld __conv sub_group_scan_exclusive_min(double x);

double  __ovld __conv sub_group_scan_exclusive_max(double x);

double  __ovld __conv sub_group_scan_inclusive_add(double x);

double  __ovld __conv sub_group_scan_inclusive_min(double x);

double  __ovld __conv sub_group_scan_inclusive_max(double x);

#endif //cl_khr_fp64


#endif //cl_khr_subgroups cl_intel_subgroups


#if defined(cl_khr_subgroup_extended_types)

char __ovld __conv sub_group_broadcast( char value, uint index );

char2 __ovld __conv sub_group_broadcast( char2 value, uint index );

char3 __ovld __conv sub_group_broadcast( char3 value, uint index );

char4 __ovld __conv sub_group_broadcast( char4 value, uint index );

char8 __ovld __conv sub_group_broadcast( char8 value, uint index );

char16 __ovld __conv sub_group_broadcast( char16 value, uint index );


uchar __ovld __conv sub_group_broadcast( uchar value, uint index );

uchar2 __ovld __conv sub_group_broadcast( uchar2 value, uint index );

uchar3 __ovld __conv sub_group_broadcast( uchar3 value, uint index );

uchar4 __ovld __conv sub_group_broadcast( uchar4 value, uint index );

uchar8 __ovld __conv sub_group_broadcast( uchar8 value, uint index );

uchar16 __ovld __conv sub_group_broadcast( uchar16 value, uint index );


short __ovld __conv sub_group_broadcast( short value, uint index );

short2 __ovld __conv sub_group_broadcast( short2 value, uint index );

short3 __ovld __conv sub_group_broadcast( short3 value, uint index );

short4 __ovld __conv sub_group_broadcast( short4 value, uint index );

short8 __ovld __conv sub_group_broadcast( short8 value, uint index );

short16 __ovld __conv sub_group_broadcast( short16 value, uint index );


ushort __ovld __conv sub_group_broadcast( ushort value, uint index );

ushort2 __ovld __conv sub_group_broadcast( ushort2 value, uint index );

ushort3 __ovld __conv sub_group_broadcast( ushort3 value, uint index );

ushort4 __ovld __conv sub_group_broadcast( ushort4 value, uint index );

ushort8 __ovld __conv sub_group_broadcast( ushort8 value, uint index );

ushort16 __ovld __conv sub_group_broadcast( ushort16 value, uint index );


// scalar int broadcast is part of cl_khr_subgroups

int2 __ovld __conv sub_group_broadcast( int2 value, uint index );

int3 __ovld __conv sub_group_broadcast( int3 value, uint index );

int4 __ovld __conv sub_group_broadcast( int4 value, uint index );

int8 __ovld __conv sub_group_broadcast( int8 value, uint index );

int16 __ovld __conv sub_group_broadcast( int16 value, uint index );


// scalar uint broadcast is part of cl_khr_subgroups

uint2 __ovld __conv sub_group_broadcast( uint2 value, uint index );

uint3 __ovld __conv sub_group_broadcast( uint3 value, uint index );

uint4 __ovld __conv sub_group_broadcast( uint4 value, uint index );

uint8 __ovld __conv sub_group_broadcast( uint8 value, uint index );

uint16 __ovld __conv sub_group_broadcast( uint16 value, uint index );


// scalar long broadcast is part of cl_khr_subgroups

long2 __ovld __conv sub_group_broadcast( long2 value, uint index );

long3 __ovld __conv sub_group_broadcast( long3 value, uint index );

long4 __ovld __conv sub_group_broadcast( long4 value, uint index );

long8 __ovld __conv sub_group_broadcast( long8 value, uint index );

long16 __ovld __conv sub_group_broadcast( long16 value, uint index );


// scalar ulong broadcast is part of cl_khr_subgroups

ulong2 __ovld __conv sub_group_broadcast( ulong2 value, uint index );

ulong3 __ovld __conv sub_group_broadcast( ulong3 value, uint index );

ulong4 __ovld __conv sub_group_broadcast( ulong4 value, uint index );

ulong8 __ovld __conv sub_group_broadcast( ulong8 value, uint index );

ulong16 __ovld __conv sub_group_broadcast( ulong16 value, uint index );


// scalar float broadcast is part of cl_khr_subgroups

float2 __ovld __conv sub_group_broadcast( float2 value, uint index );

float3 __ovld __conv sub_group_broadcast( float3 value, uint index );

float4 __ovld __conv sub_group_broadcast( float4 value, uint index );

float8 __ovld __conv sub_group_broadcast( float8 value, uint index );

float16 __ovld __conv sub_group_broadcast( float16 value, uint index );


char __ovld __conv sub_group_reduce_add( char value );

uchar __ovld __conv sub_group_reduce_add( uchar value );

short __ovld __conv sub_group_reduce_add( short value );

ushort __ovld __conv sub_group_reduce_add( ushort value );


char __ovld __conv sub_group_reduce_min( char value );

uchar __ovld __conv sub_group_reduce_min( uchar value );

short __ovld __conv sub_group_reduce_min( short value );

ushort __ovld __conv sub_group_reduce_min( ushort value );


char __ovld __conv sub_group_reduce_max( char value );

uchar __ovld __conv sub_group_reduce_max( uchar value );

short __ovld __conv sub_group_reduce_max( short value );

ushort __ovld __conv sub_group_reduce_max( ushort value );


char __ovld __conv sub_group_scan_inclusive_add( char value );

uchar __ovld __conv sub_group_scan_inclusive_add( uchar value );

short __ovld __conv sub_group_scan_inclusive_add( short value );

ushort __ovld __conv sub_group_scan_inclusive_add( ushort value );


char __ovld __conv sub_group_scan_inclusive_min( char value );

uchar __ovld __conv sub_group_scan_inclusive_min( uchar value );

short __ovld __conv sub_group_scan_inclusive_min( short value );

ushort __ovld __conv sub_group_scan_inclusive_min( ushort value );


char __ovld __conv sub_group_scan_inclusive_max( char value );

uchar __ovld __conv sub_group_scan_inclusive_max( uchar value );

short __ovld __conv sub_group_scan_inclusive_max( short value );

ushort __ovld __conv sub_group_scan_inclusive_max( ushort value );


char __ovld __conv sub_group_scan_exclusive_add( char value );

uchar __ovld __conv sub_group_scan_exclusive_add( uchar value );

short __ovld __conv sub_group_scan_exclusive_add( short value );

ushort __ovld __conv sub_group_scan_exclusive_add( ushort value );


char __ovld __conv sub_group_scan_exclusive_min( char value );

uchar __ovld __conv sub_group_scan_exclusive_min( uchar value );

short __ovld __conv sub_group_scan_exclusive_min( short value );

ushort __ovld __conv sub_group_scan_exclusive_min( ushort value );


char __ovld __conv sub_group_scan_exclusive_max( char value );

uchar __ovld __conv sub_group_scan_exclusive_max( uchar value );

short __ovld __conv sub_group_scan_exclusive_max( short value );

ushort __ovld __conv sub_group_scan_exclusive_max( ushort value );


#if defined(cl_khr_fp16)

// scalar half broadcast is part of cl_khr_subgroups

half2 __ovld __conv sub_group_broadcast( half2 value, uint index );

half3 __ovld __conv sub_group_broadcast( half3 value, uint index );

half4 __ovld __conv sub_group_broadcast( half4 value, uint index );

half8 __ovld __conv sub_group_broadcast( half8 value, uint index );

half16 __ovld __conv sub_group_broadcast( half16 value, uint index );

#endif  // cl_khr_fp16


#if defined(cl_khr_fp64)

// scalar double broadcast is part of cl_khr_subgroups

double2 __ovld __conv sub_group_broadcast( double2 value, uint index );

double3 __ovld __conv sub_group_broadcast( double3 value, uint index );

double4 __ovld __conv sub_group_broadcast( double4 value, uint index );

double8 __ovld __conv sub_group_broadcast( double8 value, uint index );

double16 __ovld __conv sub_group_broadcast( double16 value, uint index );

#endif  // cl_khr_fp64


#endif  // cl_khr_subgroup_extended_types


#if defined(cl_khr_subgroup_non_uniform_vote)

int     __ovld sub_group_elect(void);

int     __ovld sub_group_non_uniform_all( int predicate );

int     __ovld sub_group_non_uniform_any( int predicate );


int     __ovld sub_group_non_uniform_all_equal( char value );

int     __ovld sub_group_non_uniform_all_equal( uchar value );

int     __ovld sub_group_non_uniform_all_equal( short value );

int     __ovld sub_group_non_uniform_all_equal( ushort value );

int     __ovld sub_group_non_uniform_all_equal( int value );

int     __ovld sub_group_non_uniform_all_equal( uint value );

int     __ovld sub_group_non_uniform_all_equal( long value );

int     __ovld sub_group_non_uniform_all_equal( ulong value );

int     __ovld sub_group_non_uniform_all_equal( float value );


#if defined(cl_khr_fp16)

int     __ovld sub_group_non_uniform_all_equal( half value );

#endif // cl_khr_fp16


#if defined(cl_khr_fp64)

int     __ovld sub_group_non_uniform_all_equal( double value );

#endif // cl_khr_fp64


#endif // cl_khr_subgroup_non_uniform_vote


#if defined(cl_khr_subgroup_ballot)

char    __ovld sub_group_non_uniform_broadcast( char value, uint index );

char2   __ovld sub_group_non_uniform_broadcast( char2 value, uint index );

char3   __ovld sub_group_non_uniform_broadcast( char3 value, uint index );

char4   __ovld sub_group_non_uniform_broadcast( char4 value, uint index );

char8   __ovld sub_group_non_uniform_broadcast( char8 value, uint index );

char16  __ovld sub_group_non_uniform_broadcast( char16 value, uint index );


uchar   __ovld sub_group_non_uniform_broadcast( uchar value, uint index );

uchar2  __ovld sub_group_non_uniform_broadcast( uchar2 value, uint index );

uchar3  __ovld sub_group_non_uniform_broadcast( uchar3 value, uint index );

uchar4  __ovld sub_group_non_uniform_broadcast( uchar4 value, uint index );

uchar8  __ovld sub_group_non_uniform_broadcast( uchar8 value, uint index );

uchar16 __ovld sub_group_non_uniform_broadcast( uchar16 value, uint index );


short   __ovld sub_group_non_uniform_broadcast( short value, uint index );

short2  __ovld sub_group_non_uniform_broadcast( short2 value, uint index );

short3  __ovld sub_group_non_uniform_broadcast( short3 value, uint index );

short4  __ovld sub_group_non_uniform_broadcast( short4 value, uint index );

short8  __ovld sub_group_non_uniform_broadcast( short8 value, uint index );

short16 __ovld sub_group_non_uniform_broadcast( short16 value, uint index );


ushort  __ovld sub_group_non_uniform_broadcast( ushort value, uint index );

ushort2 __ovld sub_group_non_uniform_broadcast( ushort2 value, uint index );

ushort3 __ovld sub_group_non_uniform_broadcast( ushort3 value, uint index );

ushort4 __ovld sub_group_non_uniform_broadcast( ushort4 value, uint index );

ushort8 __ovld sub_group_non_uniform_broadcast( ushort8 value, uint index );

ushort16 __ovld sub_group_non_uniform_broadcast( ushort16 value, uint index );


int     __ovld sub_group_non_uniform_broadcast( int value, uint index );

int2    __ovld sub_group_non_uniform_broadcast( int2 value, uint index );

int3    __ovld sub_group_non_uniform_broadcast( int3 value, uint index );

int4    __ovld sub_group_non_uniform_broadcast( int4 value, uint index );

int8    __ovld sub_group_non_uniform_broadcast( int8 value, uint index );

int16   __ovld sub_group_non_uniform_broadcast( int16 value, uint index );


uint    __ovld sub_group_non_uniform_broadcast( uint value, uint index );

uint2   __ovld sub_group_non_uniform_broadcast( uint2 value, uint index );

uint3   __ovld sub_group_non_uniform_broadcast( uint3 value, uint index );

uint4   __ovld sub_group_non_uniform_broadcast( uint4 value, uint index );

uint8   __ovld sub_group_non_uniform_broadcast( uint8 value, uint index );

uint16  __ovld sub_group_non_uniform_broadcast( uint16 value, uint index );


long    __ovld sub_group_non_uniform_broadcast( long value, uint index );

long2   __ovld sub_group_non_uniform_broadcast( long2 value, uint index );

long3   __ovld sub_group_non_uniform_broadcast( long3 value, uint index );

long4   __ovld sub_group_non_uniform_broadcast( long4 value, uint index );

long8   __ovld sub_group_non_uniform_broadcast( long8 value, uint index );

long16  __ovld sub_group_non_uniform_broadcast( long16 value, uint index );


ulong   __ovld sub_group_non_uniform_broadcast( ulong value, uint index );

ulong2  __ovld sub_group_non_uniform_broadcast( ulong2 value, uint index );

ulong3  __ovld sub_group_non_uniform_broadcast( ulong3 value, uint index );

ulong4  __ovld sub_group_non_uniform_broadcast( ulong4 value, uint index );

ulong8  __ovld sub_group_non_uniform_broadcast( ulong8 value, uint index );

ulong16 __ovld sub_group_non_uniform_broadcast( ulong16 value, uint index );


float   __ovld sub_group_non_uniform_broadcast( float value, uint index );

float2  __ovld sub_group_non_uniform_broadcast( float2 value, uint index );

float3  __ovld sub_group_non_uniform_broadcast( float3 value, uint index );

float4  __ovld sub_group_non_uniform_broadcast( float4 value, uint index );

float8  __ovld sub_group_non_uniform_broadcast( float8 value, uint index );

float16 __ovld sub_group_non_uniform_broadcast( float16 value, uint index );


char    __ovld sub_group_broadcast_first( char value );

uchar   __ovld sub_group_broadcast_first( uchar value );

short   __ovld sub_group_broadcast_first( short value );

ushort  __ovld sub_group_broadcast_first( ushort value );

int     __ovld sub_group_broadcast_first( int value );

uint    __ovld sub_group_broadcast_first( uint value );

long    __ovld sub_group_broadcast_first( long value );

ulong   __ovld sub_group_broadcast_first( ulong value );

float   __ovld sub_group_broadcast_first( float value );


uint4   __ovld sub_group_ballot( int predicate );

int     __ovld __cnfn sub_group_inverse_ballot( uint4 value );

int     __ovld __cnfn sub_group_ballot_bit_extract( uint4 value, uint index );

uint    __ovld __cnfn sub_group_ballot_bit_count( uint4 value );


uint    __ovld sub_group_ballot_inclusive_scan( uint4 value );

uint    __ovld sub_group_ballot_exclusive_scan( uint4 value );

uint    __ovld sub_group_ballot_find_lsb( uint4 value );

uint    __ovld sub_group_ballot_find_msb( uint4 value );


uint4   __ovld __cnfn get_sub_group_eq_mask(void);

uint4   __ovld __cnfn get_sub_group_ge_mask(void);

uint4   __ovld __cnfn get_sub_group_gt_mask(void);

uint4   __ovld __cnfn get_sub_group_le_mask(void);

uint4   __ovld __cnfn get_sub_group_lt_mask(void);


#if defined(cl_khr_fp16)

half    __ovld sub_group_non_uniform_broadcast( half value, uint index );

half2   __ovld sub_group_non_uniform_broadcast( half2 value, uint index );

half3   __ovld sub_group_non_uniform_broadcast( half3 value, uint index );

half4   __ovld sub_group_non_uniform_broadcast( half4 value, uint index );

half8   __ovld sub_group_non_uniform_broadcast( half8 value, uint index );

half16  __ovld sub_group_non_uniform_broadcast( half16 value, uint index );


half    __ovld sub_group_broadcast_first( half value );

#endif // cl_khr_fp16


#if defined(cl_khr_fp64)

double   __ovld sub_group_non_uniform_broadcast( double value, uint index );

double2  __ovld sub_group_non_uniform_broadcast( double2 value, uint index );

double3  __ovld sub_group_non_uniform_broadcast( double3 value, uint index );

double4  __ovld sub_group_non_uniform_broadcast( double4 value, uint index );

double8  __ovld sub_group_non_uniform_broadcast( double8 value, uint index );

double16 __ovld sub_group_non_uniform_broadcast( double16 value, uint index );


double   __ovld sub_group_broadcast_first( double value );

#endif // cl_khr_fp64


#endif // cl_khr_subgroup_ballot


#if defined(cl_khr_subgroup_non_uniform_arithmetic)

char    __ovld sub_group_non_uniform_reduce_add( char value );

uchar   __ovld sub_group_non_uniform_reduce_add( uchar value );

short   __ovld sub_group_non_uniform_reduce_add( short value );

ushort  __ovld sub_group_non_uniform_reduce_add( ushort value );

int     __ovld sub_group_non_uniform_reduce_add( int value );

uint    __ovld sub_group_non_uniform_reduce_add( uint value );

long    __ovld sub_group_non_uniform_reduce_add( long value );

ulong   __ovld sub_group_non_uniform_reduce_add( ulong value );

float   __ovld sub_group_non_uniform_reduce_add( float value );


char    __ovld sub_group_non_uniform_reduce_mul( char value );

uchar   __ovld sub_group_non_uniform_reduce_mul( uchar value );

short   __ovld sub_group_non_uniform_reduce_mul( short value );

ushort  __ovld sub_group_non_uniform_reduce_mul( ushort value );

int     __ovld sub_group_non_uniform_reduce_mul( int value );

uint    __ovld sub_group_non_uniform_reduce_mul( uint value );

long    __ovld sub_group_non_uniform_reduce_mul( long value );

ulong   __ovld sub_group_non_uniform_reduce_mul( ulong value );

float   __ovld sub_group_non_uniform_reduce_mul( float value );


char    __ovld sub_group_non_uniform_reduce_min( char value );

uchar   __ovld sub_group_non_uniform_reduce_min( uchar value );

short   __ovld sub_group_non_uniform_reduce_min( short value );

ushort  __ovld sub_group_non_uniform_reduce_min( ushort value );

int     __ovld sub_group_non_uniform_reduce_min( int value );

uint    __ovld sub_group_non_uniform_reduce_min( uint value );

long    __ovld sub_group_non_uniform_reduce_min( long value );

ulong   __ovld sub_group_non_uniform_reduce_min( ulong value );

float   __ovld sub_group_non_uniform_reduce_min( float value );


char    __ovld sub_group_non_uniform_reduce_max( char value );

uchar   __ovld sub_group_non_uniform_reduce_max( uchar value );

short   __ovld sub_group_non_uniform_reduce_max( short value );

ushort  __ovld sub_group_non_uniform_reduce_max( ushort value );

int     __ovld sub_group_non_uniform_reduce_max( int value );

uint    __ovld sub_group_non_uniform_reduce_max( uint value );

long    __ovld sub_group_non_uniform_reduce_max( long value );

ulong   __ovld sub_group_non_uniform_reduce_max( ulong value );

float   __ovld sub_group_non_uniform_reduce_max( float value );


char    __ovld sub_group_non_uniform_scan_inclusive_add( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_add( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_add( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_add( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_add( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_add( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_add( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_add( ulong value );

float   __ovld sub_group_non_uniform_scan_inclusive_add( float value );


char    __ovld sub_group_non_uniform_scan_inclusive_mul( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_mul( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_mul( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_mul( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_mul( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_mul( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_mul( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_mul( ulong value );

float   __ovld sub_group_non_uniform_scan_inclusive_mul( float value );


char    __ovld sub_group_non_uniform_scan_inclusive_min( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_min( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_min( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_min( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_min( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_min( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_min( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_min( ulong value );

float   __ovld sub_group_non_uniform_scan_inclusive_min( float value );


char    __ovld sub_group_non_uniform_scan_inclusive_max( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_max( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_max( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_max( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_max( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_max( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_max( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_max( ulong value );

float   __ovld sub_group_non_uniform_scan_inclusive_max( float value );


char    __ovld sub_group_non_uniform_scan_exclusive_add( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_add( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_add( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_add( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_add( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_add( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_add( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_add( ulong value );

float   __ovld sub_group_non_uniform_scan_exclusive_add( float value );


char    __ovld sub_group_non_uniform_scan_exclusive_mul( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_mul( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_mul( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_mul( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_mul( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_mul( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_mul( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_mul( ulong value );

float   __ovld sub_group_non_uniform_scan_exclusive_mul( float value );


char    __ovld sub_group_non_uniform_scan_exclusive_min( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_min( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_min( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_min( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_min( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_min( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_min( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_min( ulong value );

float   __ovld sub_group_non_uniform_scan_exclusive_min( float value );


char    __ovld sub_group_non_uniform_scan_exclusive_max( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_max( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_max( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_max( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_max( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_max( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_max( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_max( ulong value );

float   __ovld sub_group_non_uniform_scan_exclusive_max( float value );


char    __ovld sub_group_non_uniform_reduce_and( char value );

uchar   __ovld sub_group_non_uniform_reduce_and( uchar value );

short   __ovld sub_group_non_uniform_reduce_and( short value );

ushort  __ovld sub_group_non_uniform_reduce_and( ushort value );

int     __ovld sub_group_non_uniform_reduce_and( int value );

uint    __ovld sub_group_non_uniform_reduce_and( uint value );

long    __ovld sub_group_non_uniform_reduce_and( long value );

ulong   __ovld sub_group_non_uniform_reduce_and( ulong value );


char    __ovld sub_group_non_uniform_reduce_or( char value );

uchar   __ovld sub_group_non_uniform_reduce_or( uchar value );

short   __ovld sub_group_non_uniform_reduce_or( short value );

ushort  __ovld sub_group_non_uniform_reduce_or( ushort value );

int     __ovld sub_group_non_uniform_reduce_or( int value );

uint    __ovld sub_group_non_uniform_reduce_or( uint value );

long    __ovld sub_group_non_uniform_reduce_or( long value );

ulong   __ovld sub_group_non_uniform_reduce_or( ulong value );


char    __ovld sub_group_non_uniform_reduce_xor( char value );

uchar   __ovld sub_group_non_uniform_reduce_xor( uchar value );

short   __ovld sub_group_non_uniform_reduce_xor( short value );

ushort  __ovld sub_group_non_uniform_reduce_xor( ushort value );

int     __ovld sub_group_non_uniform_reduce_xor( int value );

uint    __ovld sub_group_non_uniform_reduce_xor( uint value );

long    __ovld sub_group_non_uniform_reduce_xor( long value );

ulong   __ovld sub_group_non_uniform_reduce_xor( ulong value );


char    __ovld sub_group_non_uniform_scan_inclusive_and( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_and( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_and( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_and( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_and( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_and( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_and( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_and( ulong value );


char    __ovld sub_group_non_uniform_scan_inclusive_or( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_or( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_or( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_or( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_or( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_or( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_or( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_or( ulong value );


char    __ovld sub_group_non_uniform_scan_inclusive_xor( char value );

uchar   __ovld sub_group_non_uniform_scan_inclusive_xor( uchar value );

short   __ovld sub_group_non_uniform_scan_inclusive_xor( short value );

ushort  __ovld sub_group_non_uniform_scan_inclusive_xor( ushort value );

int     __ovld sub_group_non_uniform_scan_inclusive_xor( int value );

uint    __ovld sub_group_non_uniform_scan_inclusive_xor( uint value );

long    __ovld sub_group_non_uniform_scan_inclusive_xor( long value );

ulong   __ovld sub_group_non_uniform_scan_inclusive_xor( ulong value );


char    __ovld sub_group_non_uniform_scan_exclusive_and( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_and( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_and( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_and( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_and( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_and( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_and( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_and( ulong value );


char    __ovld sub_group_non_uniform_scan_exclusive_or( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_or( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_or( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_or( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_or( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_or( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_or( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_or( ulong value );


char    __ovld sub_group_non_uniform_scan_exclusive_xor( char value );

uchar   __ovld sub_group_non_uniform_scan_exclusive_xor( uchar value );

short   __ovld sub_group_non_uniform_scan_exclusive_xor( short value );

ushort  __ovld sub_group_non_uniform_scan_exclusive_xor( ushort value );

int     __ovld sub_group_non_uniform_scan_exclusive_xor( int value );

uint    __ovld sub_group_non_uniform_scan_exclusive_xor( uint value );

long    __ovld sub_group_non_uniform_scan_exclusive_xor( long value );

ulong   __ovld sub_group_non_uniform_scan_exclusive_xor( ulong value );


int     __ovld sub_group_non_uniform_reduce_logical_and( int predicate );

int     __ovld sub_group_non_uniform_reduce_logical_or( int predicate );

int     __ovld sub_group_non_uniform_reduce_logical_xor( int predicate );


int     __ovld sub_group_non_uniform_scan_inclusive_logical_and( int predicate );

int     __ovld sub_group_non_uniform_scan_inclusive_logical_or( int predicate );

int     __ovld sub_group_non_uniform_scan_inclusive_logical_xor( int predicate );


int     __ovld sub_group_non_uniform_scan_exclusive_logical_and( int predicate );

int     __ovld sub_group_non_uniform_scan_exclusive_logical_or( int predicate );

int     __ovld sub_group_non_uniform_scan_exclusive_logical_xor( int predicate );


#if defined(cl_khr_fp16)

half    __ovld sub_group_non_uniform_reduce_add( half value );

half    __ovld sub_group_non_uniform_reduce_mul( half value );

half    __ovld sub_group_non_uniform_reduce_min( half value );

half    __ovld sub_group_non_uniform_reduce_max( half value );

half    __ovld sub_group_non_uniform_scan_inclusive_add( half value );

half    __ovld sub_group_non_uniform_scan_inclusive_mul( half value );

half    __ovld sub_group_non_uniform_scan_inclusive_min( half value );

half    __ovld sub_group_non_uniform_scan_inclusive_max( half value );

half    __ovld sub_group_non_uniform_scan_exclusive_add( half value );

half    __ovld sub_group_non_uniform_scan_exclusive_mul( half value );

half    __ovld sub_group_non_uniform_scan_exclusive_min( half value );

half    __ovld sub_group_non_uniform_scan_exclusive_max( half value );

#endif // cl_khr_fp16


#if defined(cl_khr_fp64)

double  __ovld sub_group_non_uniform_reduce_add( double value );

double  __ovld sub_group_non_uniform_reduce_mul( double value );

double  __ovld sub_group_non_uniform_reduce_min( double value );

double  __ovld sub_group_non_uniform_reduce_max( double value );

double  __ovld sub_group_non_uniform_scan_inclusive_add( double value );

double  __ovld sub_group_non_uniform_scan_inclusive_mul( double value );

double  __ovld sub_group_non_uniform_scan_inclusive_min( double value );

double  __ovld sub_group_non_uniform_scan_inclusive_max( double value );

double  __ovld sub_group_non_uniform_scan_exclusive_add( double value );

double  __ovld sub_group_non_uniform_scan_exclusive_mul( double value );

double  __ovld sub_group_non_uniform_scan_exclusive_min( double value );

double  __ovld sub_group_non_uniform_scan_exclusive_max( double value );

#endif // cl_khr_fp64


#endif // cl_khr_subgroup_non_uniform_arithmetic


#if defined(cl_khr_subgroup_shuffle)

char    __ovld sub_group_shuffle( char value, uint index );

uchar   __ovld sub_group_shuffle( uchar value, uint index );

short   __ovld sub_group_shuffle( short value, uint index );

ushort  __ovld sub_group_shuffle( ushort value, uint index );

int     __ovld sub_group_shuffle( int value, uint index );

uint    __ovld sub_group_shuffle( uint value, uint index );

long    __ovld sub_group_shuffle( long value, uint index );

ulong   __ovld sub_group_shuffle( ulong value, uint index );

float   __ovld sub_group_shuffle( float value, uint index );


char    __ovld sub_group_shuffle_xor( char value, uint mask );

uchar   __ovld sub_group_shuffle_xor( uchar value, uint mask );

short   __ovld sub_group_shuffle_xor( short value, uint mask );

ushort  __ovld sub_group_shuffle_xor( ushort value, uint mask );

int     __ovld sub_group_shuffle_xor( int value, uint mask );

uint    __ovld sub_group_shuffle_xor( uint value, uint mask );

long    __ovld sub_group_shuffle_xor( long value, uint mask );

ulong   __ovld sub_group_shuffle_xor( ulong value, uint mask );

float   __ovld sub_group_shuffle_xor( float value, uint mask );


#if defined(cl_khr_fp16)

half    __ovld sub_group_shuffle( half value, uint index );

half    __ovld sub_group_shuffle_xor( half value, uint mask );

#endif // cl_khr_fp16


#if defined(cl_khr_fp64)

double  __ovld sub_group_shuffle( double value, uint index );

double  __ovld sub_group_shuffle_xor( double value, uint mask );

#endif // cl_khr_fp64


#endif // cl_khr_subgroup_shuffle


#if defined(cl_khr_subgroup_shuffle_relative)

char    __ovld sub_group_shuffle_up( char value, uint delta );

uchar   __ovld sub_group_shuffle_up( uchar value, uint delta );

short   __ovld sub_group_shuffle_up( short value, uint delta );

ushort  __ovld sub_group_shuffle_up( ushort value, uint delta );

int     __ovld sub_group_shuffle_up( int value, uint delta );

uint    __ovld sub_group_shuffle_up( uint value, uint delta );

long    __ovld sub_group_shuffle_up( long value, uint delta );

ulong   __ovld sub_group_shuffle_up( ulong value, uint delta );

float   __ovld sub_group_shuffle_up( float value, uint delta );


char    __ovld sub_group_shuffle_down( char value, uint delta );

uchar   __ovld sub_group_shuffle_down( uchar value, uint delta );

short   __ovld sub_group_shuffle_down( short value, uint delta );

ushort  __ovld sub_group_shuffle_down( ushort value, uint delta );

int     __ovld sub_group_shuffle_down( int value, uint delta );

uint    __ovld sub_group_shuffle_down( uint value, uint delta );

long    __ovld sub_group_shuffle_down( long value, uint delta );

ulong   __ovld sub_group_shuffle_down( ulong value, uint delta );

float   __ovld sub_group_shuffle_down( float value, uint delta );


#if defined(cl_khr_fp16)

half    __ovld sub_group_shuffle_up( half value, uint delta );

half    __ovld sub_group_shuffle_down( half value, uint delta );

#endif // cl_khr_fp16


#if defined(cl_khr_fp64)

double  __ovld sub_group_shuffle_up( double value, uint delta );

double  __ovld sub_group_shuffle_down( double value, uint delta );

#endif // cl_khr_fp64


#endif // cl_khr_subgroup_shuffle_relative


#if defined(cl_khr_subgroup_clustered_reduce)

char    __ovld sub_group_clustered_reduce_add( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_add( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_add( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_add( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_add( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_add( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_add( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_add( ulong value, uint clustersize );

float   __ovld sub_group_clustered_reduce_add( float value, uint clustersize );


char    __ovld sub_group_clustered_reduce_mul( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_mul( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_mul( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_mul( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_mul( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_mul( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_mul( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_mul( ulong value, uint clustersize );

float   __ovld sub_group_clustered_reduce_mul( float value, uint clustersize );


char    __ovld sub_group_clustered_reduce_min( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_min( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_min( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_min( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_min( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_min( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_min( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_min( ulong value, uint clustersize );

float   __ovld sub_group_clustered_reduce_min( float value, uint clustersize );


char    __ovld sub_group_clustered_reduce_max( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_max( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_max( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_max( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_max( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_max( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_max( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_max( ulong value, uint clustersize );

float   __ovld sub_group_clustered_reduce_max( float value, uint clustersize );


char    __ovld sub_group_clustered_reduce_and( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_and( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_and( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_and( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_and( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_and( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_and( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_and( ulong value, uint clustersize );


char    __ovld sub_group_clustered_reduce_or( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_or( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_or( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_or( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_or( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_or( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_or( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_or( ulong value, uint clustersize );


char    __ovld sub_group_clustered_reduce_xor( char value, uint clustersize );

uchar   __ovld sub_group_clustered_reduce_xor( uchar value, uint clustersize );

short   __ovld sub_group_clustered_reduce_xor( short value, uint clustersize );

ushort  __ovld sub_group_clustered_reduce_xor( ushort value, uint clustersize );

int     __ovld sub_group_clustered_reduce_xor( int value, uint clustersize );

uint    __ovld sub_group_clustered_reduce_xor( uint value, uint clustersize );

long    __ovld sub_group_clustered_reduce_xor( long value, uint clustersize );

ulong   __ovld sub_group_clustered_reduce_xor( ulong value, uint clustersize );


int     __ovld sub_group_clustered_reduce_logical_and( int predicate, uint clustersize );

int     __ovld sub_group_clustered_reduce_logical_or( int predicate, uint clustersize );

int     __ovld sub_group_clustered_reduce_logical_xor( int predicate, uint clustersize );


#if defined(cl_khr_fp16)

half    __ovld sub_group_clustered_reduce_add( half value, uint clustersize );

half    __ovld sub_group_clustered_reduce_mul( half value, uint clustersize );

half    __ovld sub_group_clustered_reduce_min( half value, uint clustersize );

half    __ovld sub_group_clustered_reduce_max( half value, uint clustersize );

#endif // cl_khr_fp16


#if defined(cl_khr_fp64)

double  __ovld sub_group_clustered_reduce_add( double value, uint clustersize );

double  __ovld sub_group_clustered_reduce_mul( double value, uint clustersize );

double  __ovld sub_group_clustered_reduce_min( double value, uint clustersize );

double  __ovld sub_group_clustered_reduce_max( double value, uint clustersize );

#endif // cl_khr_fp64


#endif // cl_khr_subgroup_clustered_reduce


#if defined(cl_intel_subgroups)

// Intel-Specific Sub Group Functions

float   __ovld __conv intel_sub_group_shuffle( float  x, uint c );

float2  __ovld __conv intel_sub_group_shuffle( float2 x, uint c );

float3  __ovld __conv intel_sub_group_shuffle( float3 x, uint c );

float4  __ovld __conv intel_sub_group_shuffle( float4 x, uint c );

float8  __ovld __conv intel_sub_group_shuffle( float8 x, uint c );

float16 __ovld __conv intel_sub_group_shuffle( float16 x, uint c );


int     __ovld __conv intel_sub_group_shuffle( int  x, uint c );

int2    __ovld __conv intel_sub_group_shuffle( int2 x, uint c );

int3    __ovld __conv intel_sub_group_shuffle( int3 x, uint c );

int4    __ovld __conv intel_sub_group_shuffle( int4 x, uint c );

int8    __ovld __conv intel_sub_group_shuffle( int8 x, uint c );

int16   __ovld __conv intel_sub_group_shuffle( int16 x, uint c );


uint    __ovld __conv intel_sub_group_shuffle( uint  x, uint c );

uint2   __ovld __conv intel_sub_group_shuffle( uint2 x, uint c );

uint3   __ovld __conv intel_sub_group_shuffle( uint3 x, uint c );

uint4   __ovld __conv intel_sub_group_shuffle( uint4 x, uint c );

uint8   __ovld __conv intel_sub_group_shuffle( uint8 x, uint c );

uint16  __ovld __conv intel_sub_group_shuffle( uint16 x, uint c );


long    __ovld __conv intel_sub_group_shuffle( long x, uint c );

ulong   __ovld __conv intel_sub_group_shuffle( ulong x, uint c );


float   __ovld __conv intel_sub_group_shuffle_down( float  cur, float  next, uint c );

float2  __ovld __conv intel_sub_group_shuffle_down( float2 cur, float2 next, uint c );

float3  __ovld __conv intel_sub_group_shuffle_down( float3 cur, float3 next, uint c );

float4  __ovld __conv intel_sub_group_shuffle_down( float4 cur, float4 next, uint c );

float8  __ovld __conv intel_sub_group_shuffle_down( float8 cur, float8 next, uint c );

float16 __ovld __conv intel_sub_group_shuffle_down( float16 cur, float16 next, uint c );


int     __ovld __conv intel_sub_group_shuffle_down( int  cur, int  next, uint c );

int2    __ovld __conv intel_sub_group_shuffle_down( int2 cur, int2 next, uint c );

int3    __ovld __conv intel_sub_group_shuffle_down( int3 cur, int3 next, uint c );

int4    __ovld __conv intel_sub_group_shuffle_down( int4 cur, int4 next, uint c );

int8    __ovld __conv intel_sub_group_shuffle_down( int8 cur, int8 next, uint c );

int16   __ovld __conv intel_sub_group_shuffle_down( int16 cur, int16 next, uint c );


uint    __ovld __conv intel_sub_group_shuffle_down( uint  cur, uint  next, uint c );

uint2   __ovld __conv intel_sub_group_shuffle_down( uint2 cur, uint2 next, uint c );

uint3   __ovld __conv intel_sub_group_shuffle_down( uint3 cur, uint3 next, uint c );

uint4   __ovld __conv intel_sub_group_shuffle_down( uint4 cur, uint4 next, uint c );

uint8   __ovld __conv intel_sub_group_shuffle_down( uint8 cur, uint8 next, uint c );

uint16  __ovld __conv intel_sub_group_shuffle_down( uint16 cur, uint16 next, uint c );


long    __ovld __conv intel_sub_group_shuffle_down( long prev, long cur, uint c );

ulong   __ovld __conv intel_sub_group_shuffle_down( ulong prev, ulong cur, uint c );


float   __ovld __conv intel_sub_group_shuffle_up( float  prev, float  cur, uint c );

float2  __ovld __conv intel_sub_group_shuffle_up( float2 prev, float2 cur, uint c );

float3  __ovld __conv intel_sub_group_shuffle_up( float3 prev, float3 cur, uint c );

float4  __ovld __conv intel_sub_group_shuffle_up( float4 prev, float4 cur, uint c );

float8  __ovld __conv intel_sub_group_shuffle_up( float8 prev, float8 cur, uint c );

float16 __ovld __conv intel_sub_group_shuffle_up( float16 prev, float16 cur, uint c );


int     __ovld __conv intel_sub_group_shuffle_up( int  prev, int  cur, uint c );

int2    __ovld __conv intel_sub_group_shuffle_up( int2 prev, int2 cur, uint c );

int3    __ovld __conv intel_sub_group_shuffle_up( int3 prev, int3 cur, uint c );

int4    __ovld __conv intel_sub_group_shuffle_up( int4 prev, int4 cur, uint c );

int8    __ovld __conv intel_sub_group_shuffle_up( int8 prev, int8 cur, uint c );

int16   __ovld __conv intel_sub_group_shuffle_up( int16 prev, int16 cur, uint c );


uint    __ovld __conv intel_sub_group_shuffle_up( uint  prev, uint  cur, uint c );

uint2   __ovld __conv intel_sub_group_shuffle_up( uint2 prev, uint2 cur, uint c );

uint3   __ovld __conv intel_sub_group_shuffle_up( uint3 prev, uint3 cur, uint c );

uint4   __ovld __conv intel_sub_group_shuffle_up( uint4 prev, uint4 cur, uint c );

uint8   __ovld __conv intel_sub_group_shuffle_up( uint8 prev, uint8 cur, uint c );

uint16  __ovld __conv intel_sub_group_shuffle_up( uint16 prev, uint16 cur, uint c );


long    __ovld __conv intel_sub_group_shuffle_up( long prev, long cur, uint c );

ulong   __ovld __conv intel_sub_group_shuffle_up( ulong prev, ulong cur, uint c );


float   __ovld __conv intel_sub_group_shuffle_xor( float  x, uint c );

float2  __ovld __conv intel_sub_group_shuffle_xor( float2 x, uint c );

float3  __ovld __conv intel_sub_group_shuffle_xor( float3 x, uint c );

float4  __ovld __conv intel_sub_group_shuffle_xor( float4 x, uint c );

float8  __ovld __conv intel_sub_group_shuffle_xor( float8 x, uint c );

float16 __ovld __conv intel_sub_group_shuffle_xor( float16 x, uint c );


int     __ovld __conv intel_sub_group_shuffle_xor( int  x, uint c );

int2    __ovld __conv intel_sub_group_shuffle_xor( int2 x, uint c );

int3    __ovld __conv intel_sub_group_shuffle_xor( int3 x, uint c );

int4    __ovld __conv intel_sub_group_shuffle_xor( int4 x, uint c );

int8    __ovld __conv intel_sub_group_shuffle_xor( int8 x, uint c );

int16   __ovld __conv intel_sub_group_shuffle_xor( int16 x, uint c );


uint    __ovld __conv intel_sub_group_shuffle_xor( uint  x, uint c );

uint2   __ovld __conv intel_sub_group_shuffle_xor( uint2 x, uint c );

uint3   __ovld __conv intel_sub_group_shuffle_xor( uint3 x, uint c );

uint4   __ovld __conv intel_sub_group_shuffle_xor( uint4 x, uint c );

uint8   __ovld __conv intel_sub_group_shuffle_xor( uint8 x, uint c );

uint16  __ovld __conv intel_sub_group_shuffle_xor( uint16 x, uint c );


long    __ovld __conv intel_sub_group_shuffle_xor( long x, uint c );

ulong   __ovld __conv intel_sub_group_shuffle_xor( ulong x, uint c );


uint    __ovld __conv intel_sub_group_block_read( read_only image2d_t image, int2 coord );

uint2   __ovld __conv intel_sub_group_block_read2( read_only image2d_t image, int2 coord );

uint4   __ovld __conv intel_sub_group_block_read4( read_only image2d_t image, int2 coord );

uint8   __ovld __conv intel_sub_group_block_read8( read_only image2d_t image, int2 coord );


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

uint    __ovld __conv intel_sub_group_block_read(read_write image2d_t image, int2 coord);

uint2   __ovld __conv intel_sub_group_block_read2(read_write image2d_t image, int2 coord);

uint4   __ovld __conv intel_sub_group_block_read4(read_write image2d_t image, int2 coord);

uint8   __ovld __conv intel_sub_group_block_read8(read_write image2d_t image, int2 coord);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


uint    __ovld __conv intel_sub_group_block_read( const __global uint* p );

uint2   __ovld __conv intel_sub_group_block_read2( const __global uint* p );

uint4   __ovld __conv intel_sub_group_block_read4( const __global uint* p );

uint8   __ovld __conv intel_sub_group_block_read8( const __global uint* p );


void    __ovld __conv intel_sub_group_block_write(write_only image2d_t image, int2 coord, uint data);

void    __ovld __conv intel_sub_group_block_write2(write_only image2d_t image, int2 coord, uint2 data);

void    __ovld __conv intel_sub_group_block_write4(write_only image2d_t image, int2 coord, uint4 data);

void    __ovld __conv intel_sub_group_block_write8(write_only image2d_t image, int2 coord, uint8 data);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void    __ovld __conv intel_sub_group_block_write(read_write image2d_t image, int2 coord, uint data);

void    __ovld __conv intel_sub_group_block_write2(read_write image2d_t image, int2 coord, uint2 data);

void    __ovld __conv intel_sub_group_block_write4(read_write image2d_t image, int2 coord, uint4 data);

void    __ovld __conv intel_sub_group_block_write8(read_write image2d_t image, int2 coord, uint8 data);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


void    __ovld __conv intel_sub_group_block_write( __global uint* p, uint data );

void    __ovld __conv intel_sub_group_block_write2( __global uint* p, uint2 data );

void    __ovld __conv intel_sub_group_block_write4( __global uint* p, uint4 data );

void    __ovld __conv intel_sub_group_block_write8( __global uint* p, uint8 data );


#ifdef cl_khr_fp16

half    __ovld __conv intel_sub_group_shuffle( half x, uint c );

half    __ovld __conv intel_sub_group_shuffle_down( half prev, half cur, uint c );

half    __ovld __conv intel_sub_group_shuffle_up( half prev, half cur, uint c );

half    __ovld __conv intel_sub_group_shuffle_xor( half x, uint c );

#endif


#if defined(cl_khr_fp64)

double  __ovld __conv intel_sub_group_shuffle( double x, uint c );

double  __ovld __conv intel_sub_group_shuffle_down( double prev, double cur, uint c );

double  __ovld __conv intel_sub_group_shuffle_up( double prev, double cur, uint c );

double  __ovld __conv intel_sub_group_shuffle_xor( double x, uint c );

#endif


#endif //cl_intel_subgroups


#if defined(cl_intel_subgroups_short)

short       __ovld __conv intel_sub_group_broadcast( short  x, uint sub_group_local_id );

short2      __ovld __conv intel_sub_group_broadcast( short2 x, uint sub_group_local_id );

short3      __ovld __conv intel_sub_group_broadcast( short3 x, uint sub_group_local_id );

short4      __ovld __conv intel_sub_group_broadcast( short4 x, uint sub_group_local_id );

short8      __ovld __conv intel_sub_group_broadcast( short8 x, uint sub_group_local_id );


ushort      __ovld __conv intel_sub_group_broadcast( ushort  x, uint sub_group_local_id );

ushort2     __ovld __conv intel_sub_group_broadcast( ushort2 x, uint sub_group_local_id );

ushort3     __ovld __conv intel_sub_group_broadcast( ushort3 x, uint sub_group_local_id );

ushort4     __ovld __conv intel_sub_group_broadcast( ushort4 x, uint sub_group_local_id );

ushort8     __ovld __conv intel_sub_group_broadcast( ushort8 x, uint sub_group_local_id );


short       __ovld __conv intel_sub_group_shuffle( short   x, uint c );

short2      __ovld __conv intel_sub_group_shuffle( short2  x, uint c );

short3      __ovld __conv intel_sub_group_shuffle( short3  x, uint c );

short4      __ovld __conv intel_sub_group_shuffle( short4  x, uint c );

short8      __ovld __conv intel_sub_group_shuffle( short8  x, uint c );

short16     __ovld __conv intel_sub_group_shuffle( short16 x, uint c);


ushort      __ovld __conv intel_sub_group_shuffle( ushort   x, uint c );

ushort2     __ovld __conv intel_sub_group_shuffle( ushort2  x, uint c );

ushort3     __ovld __conv intel_sub_group_shuffle( ushort3  x, uint c );

ushort4     __ovld __conv intel_sub_group_shuffle( ushort4  x, uint c );

ushort8     __ovld __conv intel_sub_group_shuffle( ushort8  x, uint c );

ushort16    __ovld __conv intel_sub_group_shuffle( ushort16 x, uint c );


short       __ovld __conv intel_sub_group_shuffle_down( short   cur, short   next, uint c );

short2      __ovld __conv intel_sub_group_shuffle_down( short2  cur, short2  next, uint c );

short3      __ovld __conv intel_sub_group_shuffle_down( short3  cur, short3  next, uint c );

short4      __ovld __conv intel_sub_group_shuffle_down( short4  cur, short4  next, uint c );

short8      __ovld __conv intel_sub_group_shuffle_down( short8  cur, short8  next, uint c );

short16     __ovld __conv intel_sub_group_shuffle_down( short16 cur, short16 next, uint c );


ushort      __ovld __conv intel_sub_group_shuffle_down( ushort   cur, ushort   next, uint c );

ushort2     __ovld __conv intel_sub_group_shuffle_down( ushort2  cur, ushort2  next, uint c );

ushort3     __ovld __conv intel_sub_group_shuffle_down( ushort3  cur, ushort3  next, uint c );

ushort4     __ovld __conv intel_sub_group_shuffle_down( ushort4  cur, ushort4  next, uint c );

ushort8     __ovld __conv intel_sub_group_shuffle_down( ushort8  cur, ushort8  next, uint c );

ushort16    __ovld __conv intel_sub_group_shuffle_down( ushort16 cur, ushort16 next, uint c );


short       __ovld __conv intel_sub_group_shuffle_up( short   cur, short   next, uint c );

short2      __ovld __conv intel_sub_group_shuffle_up( short2  cur, short2  next, uint c );

short3      __ovld __conv intel_sub_group_shuffle_up( short3  cur, short3  next, uint c );

short4      __ovld __conv intel_sub_group_shuffle_up( short4  cur, short4  next, uint c );

short8      __ovld __conv intel_sub_group_shuffle_up( short8  cur, short8  next, uint c );

short16     __ovld __conv intel_sub_group_shuffle_up( short16 cur, short16 next, uint c );


ushort      __ovld __conv intel_sub_group_shuffle_up( ushort   cur, ushort   next, uint c );

ushort2     __ovld __conv intel_sub_group_shuffle_up( ushort2  cur, ushort2  next, uint c );

ushort3     __ovld __conv intel_sub_group_shuffle_up( ushort3  cur, ushort3  next, uint c );

ushort4     __ovld __conv intel_sub_group_shuffle_up( ushort4  cur, ushort4  next, uint c );

ushort8     __ovld __conv intel_sub_group_shuffle_up( ushort8  cur, ushort8  next, uint c );

ushort16    __ovld __conv intel_sub_group_shuffle_up( ushort16 cur, ushort16 next, uint c );


short       __ovld __conv intel_sub_group_shuffle_xor( short   x, uint c );

short2      __ovld __conv intel_sub_group_shuffle_xor( short2  x, uint c );

short3      __ovld __conv intel_sub_group_shuffle_xor( short3  x, uint c );

short4      __ovld __conv intel_sub_group_shuffle_xor( short4  x, uint c );

short8      __ovld __conv intel_sub_group_shuffle_xor( short8  x, uint c );

short16     __ovld __conv intel_sub_group_shuffle_xor( short16 x, uint c );


ushort      __ovld __conv intel_sub_group_shuffle_xor( ushort   x, uint c );

ushort2     __ovld __conv intel_sub_group_shuffle_xor( ushort2  x, uint c );

ushort3     __ovld __conv intel_sub_group_shuffle_xor( ushort3  x, uint c );

ushort4     __ovld __conv intel_sub_group_shuffle_xor( ushort4  x, uint c );

ushort8     __ovld __conv intel_sub_group_shuffle_xor( ushort8  x, uint c );

ushort16    __ovld __conv intel_sub_group_shuffle_xor( ushort16 x, uint c );


short       __ovld __conv intel_sub_group_reduce_add( short   x );

ushort      __ovld __conv intel_sub_group_reduce_add( ushort  x );

short       __ovld __conv intel_sub_group_reduce_min( short   x );

ushort      __ovld __conv intel_sub_group_reduce_min( ushort  x );

short       __ovld __conv intel_sub_group_reduce_max( short   x );

ushort      __ovld __conv intel_sub_group_reduce_max( ushort  x );


short       __ovld __conv intel_sub_group_scan_exclusive_add( short   x );

ushort      __ovld __conv intel_sub_group_scan_exclusive_add( ushort  x );

short       __ovld __conv intel_sub_group_scan_exclusive_min( short   x );

ushort      __ovld __conv intel_sub_group_scan_exclusive_min( ushort  x );

short       __ovld __conv intel_sub_group_scan_exclusive_max( short   x );

ushort      __ovld __conv intel_sub_group_scan_exclusive_max( ushort  x );


short       __ovld __conv intel_sub_group_scan_inclusive_add( short   x );

ushort      __ovld __conv intel_sub_group_scan_inclusive_add( ushort  x );

short       __ovld __conv intel_sub_group_scan_inclusive_min( short   x );

ushort      __ovld __conv intel_sub_group_scan_inclusive_min( ushort  x );

short       __ovld __conv intel_sub_group_scan_inclusive_max( short   x );

ushort      __ovld __conv intel_sub_group_scan_inclusive_max( ushort  x );


uint       __ovld __conv intel_sub_group_block_read_ui( read_only image2d_t image, int2 byte_coord );

uint2      __ovld __conv intel_sub_group_block_read_ui2( read_only image2d_t image, int2 byte_coord );

uint4      __ovld __conv intel_sub_group_block_read_ui4( read_only image2d_t image, int2 byte_coord );

uint8      __ovld __conv intel_sub_group_block_read_ui8( read_only image2d_t image, int2 byte_coord );


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

uint       __ovld __conv intel_sub_group_block_read_ui( read_write image2d_t image, int2 byte_coord );

uint2      __ovld __conv intel_sub_group_block_read_ui2( read_write image2d_t image, int2 byte_coord );

uint4      __ovld __conv intel_sub_group_block_read_ui4( read_write image2d_t image, int2 byte_coord );

uint8      __ovld __conv intel_sub_group_block_read_ui8( read_write image2d_t image, int2 byte_coord );

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


uint       __ovld __conv intel_sub_group_block_read_ui( const __global uint* p );

uint2      __ovld __conv intel_sub_group_block_read_ui2( const __global uint* p );

uint4      __ovld __conv intel_sub_group_block_read_ui4( const __global uint* p );

uint8      __ovld __conv intel_sub_group_block_read_ui8( const __global uint* p );


void       __ovld __conv intel_sub_group_block_write_ui( read_only image2d_t image, int2 byte_coord, uint data );

void       __ovld __conv intel_sub_group_block_write_ui2( read_only image2d_t image, int2 byte_coord, uint2 data );

void       __ovld __conv intel_sub_group_block_write_ui4( read_only image2d_t image, int2 byte_coord, uint4 data );

void       __ovld __conv intel_sub_group_block_write_ui8( read_only image2d_t image, int2 byte_coord, uint8 data );


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void       __ovld __conv intel_sub_group_block_write_ui( read_write image2d_t image, int2 byte_coord, uint data );

void       __ovld __conv intel_sub_group_block_write_ui2( read_write image2d_t image, int2 byte_coord, uint2 data );

void       __ovld __conv intel_sub_group_block_write_ui4( read_write image2d_t image, int2 byte_coord, uint4 data );

void       __ovld __conv intel_sub_group_block_write_ui8( read_write image2d_t image, int2 byte_coord, uint8 data );

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


void       __ovld __conv intel_sub_group_block_write_ui( __global uint* p, uint data );

void       __ovld __conv intel_sub_group_block_write_ui2( __global uint* p, uint2 data );

void       __ovld __conv intel_sub_group_block_write_ui4( __global uint* p, uint4 data );

void       __ovld __conv intel_sub_group_block_write_ui8( __global uint* p, uint8 data );


ushort      __ovld __conv intel_sub_group_block_read_us( read_only image2d_t image, int2 coord );

ushort2     __ovld __conv intel_sub_group_block_read_us2( read_only image2d_t image, int2 coord );

ushort4     __ovld __conv intel_sub_group_block_read_us4( read_only image2d_t image, int2 coord );

ushort8     __ovld __conv intel_sub_group_block_read_us8( read_only image2d_t image, int2 coord );


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

ushort      __ovld __conv intel_sub_group_block_read_us(read_write image2d_t image, int2 coord);

ushort2     __ovld __conv intel_sub_group_block_read_us2(read_write image2d_t image, int2 coord);

ushort4     __ovld __conv intel_sub_group_block_read_us4(read_write image2d_t image, int2 coord);

ushort8     __ovld __conv intel_sub_group_block_read_us8(read_write image2d_t image, int2 coord);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


ushort      __ovld __conv intel_sub_group_block_read_us(  const __global ushort* p );

ushort2     __ovld __conv intel_sub_group_block_read_us2( const __global ushort* p );

ushort4     __ovld __conv intel_sub_group_block_read_us4( const __global ushort* p );

ushort8     __ovld __conv intel_sub_group_block_read_us8( const __global ushort* p );


void        __ovld __conv intel_sub_group_block_write_us(write_only image2d_t image, int2 coord, ushort  data);

void        __ovld __conv intel_sub_group_block_write_us2(write_only image2d_t image, int2 coord, ushort2 data);

void        __ovld __conv intel_sub_group_block_write_us4(write_only image2d_t image, int2 coord, ushort4 data);

void        __ovld __conv intel_sub_group_block_write_us8(write_only image2d_t image, int2 coord, ushort8 data);


#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void        __ovld __conv intel_sub_group_block_write_us(read_write image2d_t image, int2 coord, ushort  data);

void        __ovld __conv intel_sub_group_block_write_us2(read_write image2d_t image, int2 coord, ushort2 data);

void        __ovld __conv intel_sub_group_block_write_us4(read_write image2d_t image, int2 coord, ushort4 data);

void        __ovld __conv intel_sub_group_block_write_us8(read_write image2d_t image, int2 coord, ushort8 data);

#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)


void        __ovld __conv intel_sub_group_block_write_us(  __global ushort* p, ushort  data );

void        __ovld __conv intel_sub_group_block_write_us2( __global ushort* p, ushort2 data );

void        __ovld __conv intel_sub_group_block_write_us4( __global ushort* p, ushort4 data );

void        __ovld __conv intel_sub_group_block_write_us8( __global ushort* p, ushort8 data );

#endif // cl_intel_subgroups_short


#ifdef cl_intel_device_side_avc_motion_estimation

#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : begin


// MCE built-in functions

uchar __ovld

intel_sub_group_avc_mce_get_default_inter_base_multi_reference_penalty(

    uchar slice_type, uchar qp);

ulong __ovld intel_sub_group_avc_mce_get_default_inter_shape_penalty(

    uchar slice_type, uchar qp);

uchar __ovld intel_sub_group_avc_mce_get_default_inter_direction_penalty(

    uchar slice_type, uchar qp);

uint __ovld intel_sub_group_avc_mce_get_default_intra_luma_shape_penalty(

    uchar slice_type, uchar qp);

uint2 __ovld

intel_sub_group_avc_mce_get_default_inter_motion_vector_cost_table(

    uchar slice_type, uchar qp);

uchar __ovld intel_sub_group_avc_mce_get_default_intra_luma_mode_penalty(

    uchar slice_type, uchar qp);


uint2 __ovld intel_sub_group_avc_mce_get_default_high_penalty_cost_table();

uint2 __ovld intel_sub_group_avc_mce_get_default_medium_penalty_cost_table();

uint2 __ovld intel_sub_group_avc_mce_get_default_low_penalty_cost_table();

uint __ovld intel_sub_group_avc_mce_get_default_non_dc_luma_intra_penalty();

uchar __ovld

intel_sub_group_avc_mce_get_default_intra_chroma_mode_base_penalty();


intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_inter_base_multi_reference_penalty(

    uchar reference_base_penalty, intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_inter_shape_penalty(

    ulong packed_shape_penalty, intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_inter_direction_penalty(

    uchar direction_cost, intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_motion_vector_cost_function(

    ulong packed_cost_center_delta, uint2 packed_cost_table,

    uchar cost_precision, intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_ac_only_haar(

    intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_source_interlaced_field_polarity(

    uchar src_field_polarity, intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_single_reference_interlaced_field_polarity(

    uchar ref_field_polarity, intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_mce_set_dual_reference_interlaced_field_polarities(

    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,

    intel_sub_group_avc_mce_payload_t payload);


ulong __ovld intel_sub_group_avc_mce_get_motion_vectors(

    intel_sub_group_avc_mce_result_t result);

ushort __ovld intel_sub_group_avc_mce_get_inter_distortions(

    intel_sub_group_avc_mce_result_t result);

ushort __ovld intel_sub_group_avc_mce_get_best_inter_distortion(

    intel_sub_group_avc_mce_result_t result);

uchar __ovld intel_sub_group_avc_mce_get_inter_major_shape(

    intel_sub_group_avc_mce_result_t result);

uchar __ovld intel_sub_group_avc_mce_get_inter_minor_shapes(

    intel_sub_group_avc_mce_result_t result);

uchar __ovld intel_sub_group_avc_mce_get_inter_directions(

    intel_sub_group_avc_mce_result_t result);

uchar __ovld intel_sub_group_avc_mce_get_inter_motion_vector_count(

    intel_sub_group_avc_mce_result_t result);

uint __ovld intel_sub_group_avc_mce_get_inter_reference_ids(

    intel_sub_group_avc_mce_result_t result);

uchar __ovld

intel_sub_group_avc_mce_get_inter_reference_interlaced_field_polarities(

    uint packed_reference_ids, uint packed_reference_parameter_field_polarities,

    intel_sub_group_avc_mce_result_t result);


// IME built-in functions

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_initialize(

    ushort2 src_coord, uchar partition_mask, uchar sad_adjustment);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_single_reference(

    short2 ref_offset, uchar search_window_config,

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_dual_reference(

    short2 fwd_ref_offset, short2 bwd_ref_offset, uchar search_window_config,

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_max_motion_vector_count(

    uchar max_motion_vector_count, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_unidirectional_mix_disable(

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_early_search_termination_threshold(

    uchar threshold, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_weighted_sad(

    uint packed_sad_weights, intel_sub_group_avc_ime_payload_t payload);


__attribute__((deprecated("If you use the latest Intel driver, please use "

                          "intel_sub_group_avc_ime_ref_window_size instead",

                          "intel_sub_group_avc_ime_ref_window_size")))

ushort2 __ovld

intel_sub_group_ime_ref_window_size(uchar search_window_config, char dual_ref);

ushort2 __ovld intel_sub_group_avc_ime_ref_window_size(

    uchar search_window_config, char dual_ref);

short2 __ovld intel_sub_group_avc_ime_adjust_ref_offset(

    short2 ref_offset, ushort2 src_coord, ushort2 ref_window_size,

    ushort2 image_size);


intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_ime_evaluate_with_single_reference(

    read_only image2d_t src_image, read_only image2d_t ref_image,

    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_ime_evaluate_with_dual_reference(

    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,

    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld

intel_sub_group_avc_ime_evaluate_with_single_reference_streamout(

    read_only image2d_t src_image, read_only image2d_t ref_image,

    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld

intel_sub_group_avc_ime_evaluate_with_dual_reference_streamout(

    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,

    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_ime_evaluate_with_single_reference_streamin(

    read_only image2d_t src_image, read_only image2d_t ref_image,

    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload,

    intel_sub_group_avc_ime_single_reference_streamin_t streamin_components);

intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_ime_evaluate_with_dual_reference_streamin(

    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,

    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_ime_payload_t payload,

    intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);

intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld

intel_sub_group_avc_ime_evaluate_with_single_reference_streaminout(

    read_only image2d_t src_image, read_only image2d_t ref_image,

    sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload,

    intel_sub_group_avc_ime_single_reference_streamin_t streamin_components);

intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld

intel_sub_group_avc_ime_evaluate_with_dual_reference_streaminout(

    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,

    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_ime_payload_t payload,

    intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);


intel_sub_group_avc_ime_single_reference_streamin_t __ovld

intel_sub_group_avc_ime_get_single_reference_streamin(

    intel_sub_group_avc_ime_result_single_reference_streamout_t result);

intel_sub_group_avc_ime_dual_reference_streamin_t __ovld

intel_sub_group_avc_ime_get_dual_reference_streamin(

    intel_sub_group_avc_ime_result_dual_reference_streamout_t result);

intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_ime_strip_single_reference_streamout(

    intel_sub_group_avc_ime_result_single_reference_streamout_t result);

intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_ime_strip_dual_reference_streamout(

    intel_sub_group_avc_ime_result_dual_reference_streamout_t result);


uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors(

    intel_sub_group_avc_ime_result_single_reference_streamout_t result,

    uchar major_shape);

ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions(

    intel_sub_group_avc_ime_result_single_reference_streamout_t result,

    uchar major_shape);

uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids(

    intel_sub_group_avc_ime_result_single_reference_streamout_t result,

    uchar major_shape);

uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors(

    intel_sub_group_avc_ime_result_dual_reference_streamout_t result,

    uchar major_shape, uchar direction);

ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions(

    intel_sub_group_avc_ime_result_dual_reference_streamout_t result,

    uchar major_shape, uchar direction);

uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids(

    intel_sub_group_avc_ime_result_dual_reference_streamout_t result,

    uchar major_shape, uchar direction);


uchar __ovld intel_sub_group_avc_ime_get_border_reached(

    uchar image_select, intel_sub_group_avc_ime_result_t result);

uchar __ovld intel_sub_group_avc_ime_get_truncated_search_indication(

    intel_sub_group_avc_ime_result_t result);

uchar __ovld

intel_sub_group_avc_ime_get_unidirectional_early_search_termination(

    intel_sub_group_avc_ime_result_t result);

uint __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_motion_vector(

    intel_sub_group_avc_ime_result_t result);

ushort __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_distortion(

    intel_sub_group_avc_ime_result_t result);


// REF built-in functions

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_fme_initialize(

    ushort2 src_coord, ulong motion_vectors, uchar major_shapes,

    uchar minor_shapes, uchar directions, uchar pixel_resolution,

    uchar sad_adjustment);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_bme_initialize(

    ushort2 src_coord, ulong motion_vectors, uchar major_shapes,

    uchar minor_shapes, uchar directions, uchar pixel_resolution,

    uchar bidirectional_weight, uchar sad_adjustment);


intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_bidirectional_mix_disable(

    intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_bilinear_filter_enable(

    intel_sub_group_avc_ref_payload_t payload);


intel_sub_group_avc_ref_result_t __ovld

intel_sub_group_avc_ref_evaluate_with_single_reference(

    read_only image2d_t src_image, read_only image2d_t ref_image,

    sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_ref_result_t __ovld

intel_sub_group_avc_ref_evaluate_with_dual_reference(

    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,

    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_ref_result_t __ovld

intel_sub_group_avc_ref_evaluate_with_multi_reference(

    read_only image2d_t src_image, uint packed_reference_ids,

    sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_ref_result_t __ovld

intel_sub_group_avc_ref_evaluate_with_multi_reference(

    read_only image2d_t src_image, uint packed_reference_ids,

    uchar packed_reference_field_polarities, sampler_t vme_media_sampler,

    intel_sub_group_avc_ref_payload_t payload);


// SIC built-in functions

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_initialize(

    ushort2 src_coord);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_configure_skc(

    uint skip_block_partition_type, uint skip_motion_vector_mask,

    ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment,

    intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_configure_ipe(

    uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,

    uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,

    uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,

    uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_configure_ipe(

    uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,

    uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,

    uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,

    ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel,

    ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment,

    intel_sub_group_avc_sic_payload_t payload);

uint __ovld

intel_sub_group_avc_sic_get_motion_vector_mask(

    uint skip_block_partition_type, uchar direction);


intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_intra_luma_shape_penalty(

    uint packed_shape_cost, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_intra_luma_mode_cost_function(

    uchar luma_mode_penalty, uint luma_packed_neighbor_modes,

    uint luma_packed_non_dc_penalty, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_intra_chroma_mode_cost_function(

    uchar chroma_mode_penalty, intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_skc_bilinear_filter_enable(

    intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_skc_forward_transform_enable(

    ulong packed_sad_coefficients, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_block_based_raw_skip_sad(

    uchar block_based_skip_type,

    intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_sic_result_t __ovld

intel_sub_group_avc_sic_evaluate_ipe(

    read_only image2d_t src_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_result_t __ovld

intel_sub_group_avc_sic_evaluate_with_single_reference(

    read_only image2d_t src_image, read_only image2d_t ref_image,

    sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_result_t __ovld

intel_sub_group_avc_sic_evaluate_with_dual_reference(

    read_only image2d_t src_image, read_only image2d_t fwd_ref_image,

    read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,

    intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_result_t __ovld

intel_sub_group_avc_sic_evaluate_with_multi_reference(

    read_only image2d_t src_image, uint packed_reference_ids,

    sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_result_t __ovld

intel_sub_group_avc_sic_evaluate_with_multi_reference(

    read_only image2d_t src_image, uint packed_reference_ids,

    uchar packed_reference_field_polarities, sampler_t vme_media_sampler,

    intel_sub_group_avc_sic_payload_t payload);


uchar __ovld intel_sub_group_avc_sic_get_ipe_luma_shape(

    intel_sub_group_avc_sic_result_t result);

ushort __ovld intel_sub_group_avc_sic_get_best_ipe_luma_distortion(

    intel_sub_group_avc_sic_result_t result);

ushort __ovld intel_sub_group_avc_sic_get_best_ipe_chroma_distortion(

    intel_sub_group_avc_sic_result_t result);

ulong __ovld intel_sub_group_avc_sic_get_packed_ipe_luma_modes(

    intel_sub_group_avc_sic_result_t result);

uchar __ovld intel_sub_group_avc_sic_get_ipe_chroma_mode(

    intel_sub_group_avc_sic_result_t result);

uint __ovld intel_sub_group_avc_sic_get_packed_skc_luma_count_threshold(

    intel_sub_group_avc_sic_result_t result);

ulong __ovld intel_sub_group_avc_sic_get_packed_skc_luma_sum_threshold(

    intel_sub_group_avc_sic_result_t result);

ushort __ovld intel_sub_group_avc_sic_get_inter_raw_sads(

    intel_sub_group_avc_sic_result_t result);


// Wrappers

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_inter_base_multi_reference_penalty(

    uchar reference_base_penalty, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_inter_base_multi_reference_penalty(

    uchar reference_base_penalty, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_inter_base_multi_reference_penalty(

    uchar reference_base_penalty, intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_inter_shape_penalty(

    ulong packed_shape_cost, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_inter_shape_penalty(

    ulong packed_shape_cost, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_inter_shape_penalty(

    ulong packed_shape_cost, intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_inter_direction_penalty(

    uchar direction_cost, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_inter_direction_penalty(

    uchar direction_cost, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_inter_direction_penalty(

    uchar direction_cost, intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_motion_vector_cost_function(

    ulong packed_cost_center_delta, uint2 packed_cost_table,

    uchar cost_precision, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_motion_vector_cost_function(

    ulong packed_cost_center_delta, uint2 packed_cost_table,

    uchar cost_precision, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_motion_vector_cost_function(

    ulong packed_cost_center_delta, uint2 packed_cost_table,

    uchar cost_precision, intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_source_interlaced_field_polarity(

    uchar src_field_polarity, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_source_interlaced_field_polarity(

    uchar src_field_polarity, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_source_interlaced_field_polarity(

    uchar src_field_polarity, intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_single_reference_interlaced_field_polarity(

    uchar ref_field_polarity, intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_single_reference_interlaced_field_polarity(

    uchar ref_field_polarity, intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_single_reference_interlaced_field_polarity(

    uchar ref_field_polarity, intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_dual_reference_interlaced_field_polarities(

    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_dual_reference_interlaced_field_polarities(

    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,

    intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_dual_reference_interlaced_field_polarities(

    uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,

    intel_sub_group_avc_sic_payload_t payload);


intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_ime_set_ac_only_haar(

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_ref_set_ac_only_haar(

    intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_sic_set_ac_only_haar(

    intel_sub_group_avc_sic_payload_t payload);


ulong __ovld intel_sub_group_avc_ime_get_motion_vectors(

    intel_sub_group_avc_ime_result_t result);

ulong __ovld intel_sub_group_avc_ref_get_motion_vectors(

    intel_sub_group_avc_ref_result_t result);


ushort __ovld intel_sub_group_avc_ime_get_inter_distortions(

    intel_sub_group_avc_ime_result_t result);

ushort __ovld intel_sub_group_avc_ref_get_inter_distortions(

    intel_sub_group_avc_ref_result_t result);

ushort __ovld intel_sub_group_avc_sic_get_inter_distortions(

    intel_sub_group_avc_sic_result_t result);


ushort __ovld intel_sub_group_avc_ime_get_best_inter_distortion(

    intel_sub_group_avc_ime_result_t result);

ushort __ovld intel_sub_group_avc_ref_get_best_inter_distortion(

    intel_sub_group_avc_ref_result_t result);


uchar __ovld intel_sub_group_avc_ime_get_inter_major_shape(

    intel_sub_group_avc_ime_result_t result);

uchar __ovld intel_sub_group_avc_ref_get_inter_major_shape(

    intel_sub_group_avc_ref_result_t result);

uchar __ovld intel_sub_group_avc_ime_get_inter_minor_shapes(

    intel_sub_group_avc_ime_result_t result);

uchar __ovld intel_sub_group_avc_ref_get_inter_minor_shapes(

    intel_sub_group_avc_ref_result_t result);


uchar __ovld intel_sub_group_avc_ime_get_inter_directions(

    intel_sub_group_avc_ime_result_t result);

uchar __ovld intel_sub_group_avc_ref_get_inter_directions(

    intel_sub_group_avc_ref_result_t result);


uchar __ovld intel_sub_group_avc_ime_get_inter_motion_vector_count(

    intel_sub_group_avc_ime_result_t result);

uchar __ovld intel_sub_group_avc_ref_get_inter_motion_vector_count(

    intel_sub_group_avc_ref_result_t result);


uint __ovld intel_sub_group_avc_ime_get_inter_reference_ids(

    intel_sub_group_avc_ime_result_t result);

uint __ovld intel_sub_group_avc_ref_get_inter_reference_ids(

    intel_sub_group_avc_ref_result_t result);


uchar __ovld

intel_sub_group_avc_ime_get_inter_reference_interlaced_field_polarities(

    uint packed_reference_ids, uint packed_reference_parameter_field_polarities,

    intel_sub_group_avc_ime_result_t result);

uchar __ovld

intel_sub_group_avc_ref_get_inter_reference_interlaced_field_polarities(

    uint packed_reference_ids, uint packed_reference_parameter_field_polarities,

    intel_sub_group_avc_ref_result_t result);


// Type conversion functions

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_ime_convert_to_mce_payload(

    intel_sub_group_avc_ime_payload_t payload);

intel_sub_group_avc_ime_payload_t __ovld

intel_sub_group_avc_mce_convert_to_ime_payload(

    intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_ref_convert_to_mce_payload(

    intel_sub_group_avc_ref_payload_t payload);

intel_sub_group_avc_ref_payload_t __ovld

intel_sub_group_avc_mce_convert_to_ref_payload(

    intel_sub_group_avc_mce_payload_t payload);

intel_sub_group_avc_mce_payload_t __ovld

intel_sub_group_avc_sic_convert_to_mce_payload(

    intel_sub_group_avc_sic_payload_t payload);

intel_sub_group_avc_sic_payload_t __ovld

intel_sub_group_avc_mce_convert_to_sic_payload(

    intel_sub_group_avc_mce_payload_t payload);


intel_sub_group_avc_mce_result_t __ovld

intel_sub_group_avc_ime_convert_to_mce_result(

    intel_sub_group_avc_ime_result_t result);

intel_sub_group_avc_ime_result_t __ovld

intel_sub_group_avc_mce_convert_to_ime_result(

    intel_sub_group_avc_mce_result_t result);

intel_sub_group_avc_mce_result_t __ovld

intel_sub_group_avc_ref_convert_to_mce_result(

    intel_sub_group_avc_ref_result_t result);

intel_sub_group_avc_ref_result_t __ovld

intel_sub_group_avc_mce_convert_to_ref_result(

    intel_sub_group_avc_mce_result_t result);

intel_sub_group_avc_mce_result_t __ovld

intel_sub_group_avc_sic_convert_to_mce_result(

    intel_sub_group_avc_sic_result_t result);

intel_sub_group_avc_sic_result_t __ovld

intel_sub_group_avc_mce_convert_to_sic_result(

    intel_sub_group_avc_mce_result_t result);

#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : end

#endif // cl_intel_device_side_avc_motion_estimation


#ifdef cl_amd_media_ops

uint __ovld amd_bitalign(uint a, uint b, uint c);

uint2 __ovld amd_bitalign(uint2 a, uint2 b, uint2 c);

uint3 __ovld amd_bitalign(uint3 a, uint3 b, uint3 c);

uint4 __ovld amd_bitalign(uint4 a, uint4 b, uint4 c);

uint8 __ovld amd_bitalign(uint8 a, uint8 b, uint8 c);

uint16 __ovld amd_bitalign(uint16 a, uint16 b, uint16 c);


uint __ovld amd_bytealign(uint a, uint b, uint c);

uint2 __ovld amd_bytealign(uint2 a, uint2 b, uint2 c);

uint3 __ovld amd_bytealign(uint3 a, uint3 b, uint3 c);

uint4 __ovld amd_bytealign(uint4 a, uint4 b, uint4 c);

uint8 __ovld amd_bytealign(uint8 a, uint8 b, uint8 c);

uint16 __ovld amd_bytealign(uint16 a, uint16 b, uint16 c);


uint __ovld amd_lerp(uint a, uint b, uint c);

uint2 __ovld amd_lerp(uint2 a, uint2 b, uint2 c);

uint3 __ovld amd_lerp(uint3 a, uint3 b, uint3 c);

uint4 __ovld amd_lerp(uint4 a, uint4 b, uint4 c);

uint8 __ovld amd_lerp(uint8 a, uint8 b, uint8 c);

uint16 __ovld amd_lerp(uint16 a, uint16 b, uint16 c);


uint __ovld amd_pack(float4 v);


uint __ovld amd_sad4(uint4 x, uint4 y, uint z);


uint __ovld amd_sadhi(uint a, uint b, uint c);

uint2 __ovld amd_sadhi(uint2 a, uint2 b, uint2 c);

uint3 __ovld amd_sadhi(uint3 a, uint3 b, uint3 c);

uint4 __ovld amd_sadhi(uint4 a, uint4 b, uint4 c);

uint8 __ovld amd_sadhi(uint8 a, uint8 b, uint8 c);

uint16 __ovld amd_sadhi(uint16 a, uint16 b, uint16 c);


uint __ovld amd_sad(uint a, uint b, uint c);

uint2 __ovld amd_sad(uint2 a, uint2 b, uint2 c);

uint3 __ovld amd_sad(uint3 a, uint3 b, uint3 c);

uint4 __ovld amd_sad(uint4 a, uint4 b, uint4 c);

uint8 __ovld amd_sad(uint8 a, uint8 b, uint8 c);

uint16 __ovld amd_sad(uint16 a, uint16 b, uint16 c);


float __ovld amd_unpack0(uint a);

float2 __ovld amd_unpack0(uint2 a);

float3 __ovld amd_unpack0(uint3 a);

float4 __ovld amd_unpack0(uint4 a);

float8 __ovld amd_unpack0(uint8 a);

float16 __ovld amd_unpack0(uint16 a);


float __ovld amd_unpack1(uint a);

float2 __ovld amd_unpack1(uint2 a);

float3 __ovld amd_unpack1(uint3 a);

float4 __ovld amd_unpack1(uint4 a);

float8 __ovld amd_unpack1(uint8 a);

float16 __ovld amd_unpack1(uint16 a);


float __ovld amd_unpack2(uint a);

float2 __ovld amd_unpack2(uint2 a);

float3 __ovld amd_unpack2(uint3 a);

float4 __ovld amd_unpack2(uint4 a);

float8 __ovld amd_unpack2(uint8 a);

float16 __ovld amd_unpack2(uint16 a);


float __ovld amd_unpack3(uint a);

float2 __ovld amd_unpack3(uint2 a);

float3 __ovld amd_unpack3(uint3 a);

float4 __ovld amd_unpack3(uint4 a);

float8 __ovld amd_unpack3(uint8 a);

float16 __ovld amd_unpack3(uint16 a);

#endif // cl_amd_media_ops


#ifdef cl_amd_media_ops2

int __ovld amd_bfe(int src0, uint src1, uint src2);

int2 __ovld amd_bfe(int2 src0, uint2 src1, uint2 src2);

int3 __ovld amd_bfe(int3 src0, uint3 src1, uint3 src2);

int4 __ovld amd_bfe(int4 src0, uint4 src1, uint4 src2);

int8 __ovld amd_bfe(int8 src0, uint8 src1, uint8 src2);

int16 __ovld amd_bfe(int16 src0, uint16 src1, uint16 src2);


uint __ovld amd_bfe(uint src0, uint src1, uint src2);

uint2 __ovld amd_bfe(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_bfe(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_bfe(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_bfe(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_bfe(uint16 src0, uint16 src1, uint16 src2);


uint __ovld amd_bfm(uint src0, uint src1);

uint2 __ovld amd_bfm(uint2 src0, uint2 src1);

uint3 __ovld amd_bfm(uint3 src0, uint3 src1);

uint4 __ovld amd_bfm(uint4 src0, uint4 src1);

uint8 __ovld amd_bfm(uint8 src0, uint8 src1);

uint16 __ovld amd_bfm(uint16 src0, uint16 src1);


float __ovld amd_max3(float src0, float src1, float src2);

float2 __ovld amd_max3(float2 src0, float2 src1, float2 src2);

float3 __ovld amd_max3(float3 src0, float3 src1, float3 src2);

float4 __ovld amd_max3(float4 src0, float4 src1, float4 src2);

float8 __ovld amd_max3(float8 src0, float8 src1, float8 src2);

float16 __ovld amd_max3(float16 src0, float16 src1, float16 src2);


int __ovld amd_max3(int src0, int src1, int src2);

int2 __ovld amd_max3(int2 src0, int2 src1, int2 src2);

int3 __ovld amd_max3(int3 src0, int3 src1, int3 src2);

int4 __ovld amd_max3(int4 src0, int4 src1, int4 src2);

int8 __ovld amd_max3(int8 src0, int8 src1, int8 src2);

int16 __ovld amd_max3(int16 src0, int16 src1, int16 src2);


uint __ovld amd_max3(uint src0, uint src1, uint src2);

uint2 __ovld amd_max3(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_max3(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_max3(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_max3(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_max3(uint16 src0, uint16 src1, uint16 src2);


float __ovld amd_median3(float src0, float src1, float src2);

float2 __ovld amd_median3(float2 src0, float2 src1, float2 src2);

float3 __ovld amd_median3(float3 src0, float3 src1, float3 src2);

float4 __ovld amd_median3(float4 src0, float4 src1, float4 src2);

float8 __ovld amd_median3(float8 src0, float8 src1, float8 src2);

float16 __ovld amd_median3(float16 src0, float16 src1, float16 src2);


int __ovld amd_median3(int src0, int src1, int src2);

int2 __ovld amd_median3(int2 src0, int2 src1, int2 src2);

int3 __ovld amd_median3(int3 src0, int3 src1, int3 src2);

int4 __ovld amd_median3(int4 src0, int4 src1, int4 src2);

int8 __ovld amd_median3(int8 src0, int8 src1, int8 src2);

int16 __ovld amd_median3(int16 src0, int16 src1, int16 src2);


uint __ovld amd_median3(uint src0, uint src1, uint src2);

uint2 __ovld amd_median3(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_median3(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_median3(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_median3(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_median3(uint16 src0, uint16 src1, uint16 src2);


float __ovld amd_min3(float src0, float src1, float src);

float2 __ovld amd_min3(float2 src0, float2 src1, float2 src);

float3 __ovld amd_min3(float3 src0, float3 src1, float3 src);

float4 __ovld amd_min3(float4 src0, float4 src1, float4 src);

float8 __ovld amd_min3(float8 src0, float8 src1, float8 src);

float16 __ovld amd_min3(float16 src0, float16 src1, float16 src);


int __ovld amd_min3(int src0, int src1, int src2);

int2 __ovld amd_min3(int2 src0, int2 src1, int2 src2);

int3 __ovld amd_min3(int3 src0, int3 src1, int3 src2);

int4 __ovld amd_min3(int4 src0, int4 src1, int4 src2);

int8 __ovld amd_min3(int8 src0, int8 src1, int8 src2);

int16 __ovld amd_min3(int16 src0, int16 src1, int16 src2);


uint __ovld amd_min3(uint src0, uint src1, uint src2);

uint2 __ovld amd_min3(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_min3(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_min3(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_min3(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_min3(uint16 src0, uint16 src1, uint16 src2);


ulong __ovld amd_mqsad(ulong src0, uint src1, ulong src2);

ulong2 __ovld amd_mqsad(ulong2 src0, uint2 src1, ulong2 src2);

ulong3 __ovld amd_mqsad(ulong3 src0, uint3 src1, ulong3 src2);

ulong4 __ovld amd_mqsad(ulong4 src0, uint4 src1, ulong4 src2);

ulong8 __ovld amd_mqsad(ulong8 src0, uint8 src1, ulong8 src2);

ulong16 __ovld amd_mqsad(ulong16 src0, uint16 src1, ulong16 src2);


ulong __ovld amd_qsad(ulong src0, uint src1, ulong src2);

ulong2 __ovld amd_qsad(ulong2 src0, uint2 src1, ulong2 src2);

ulong3 __ovld amd_qsad(ulong3 src0, uint3 src1, ulong3 src2);

ulong4 __ovld amd_qsad(ulong4 src0, uint4 src1, ulong4 src2);

ulong8 __ovld amd_qsad(ulong8 src0, uint8 src1, ulong8 src2);

ulong16 __ovld amd_qsad(ulong16 src0, uint16 src1, ulong16 src2);


uint __ovld amd_msad(uint src0, uint src1, uint src2);

uint2 __ovld amd_msad(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_msad(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_msad(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_msad(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_msad(uint16 src0, uint16 src1, uint16 src2);


uint __ovld amd_sadd(uint src0, uint src1, uint src2);

uint2 __ovld amd_sadd(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_sadd(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_sadd(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_sadd(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_sadd(uint16 src0, uint16 src1, uint16 src2);


uint __ovld amd_sadw(uint src0, uint src1, uint src2);

uint2 __ovld amd_sadw(uint2 src0, uint2 src1, uint2 src2);

uint3 __ovld amd_sadw(uint3 src0, uint3 src1, uint3 src2);

uint4 __ovld amd_sadw(uint4 src0, uint4 src1, uint4 src2);

uint8 __ovld amd_sadw(uint8 src0, uint8 src1, uint8 src2);

uint16 __ovld amd_sadw(uint16 src0, uint16 src1, uint16 src2);

#endif // cl_amd_media_ops2


#if defined(cl_arm_integer_dot_product_int8)

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_int8 : begin

uint __ovld arm_dot(uchar4 a, uchar4 b);

int __ovld arm_dot(char4 a, char4 b);

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_int8 : end

#endif // defined(cl_arm_integer_dot_product_int8)


#if defined(cl_arm_integer_dot_product_accumulate_int8)

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_accumulate_int8 : begin

uint __ovld arm_dot_acc(uchar4 a, uchar4 b, uint c);

int __ovld arm_dot_acc(char4 a, char4 b, int c);

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_accumulate_int8 : end

#endif // defined(cl_arm_integer_dot_product_accumulate_int8)


#if defined(cl_arm_integer_dot_product_accumulate_int16)

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_accumulate_int16 : begin

uint __ovld arm_dot_acc(ushort2 a, ushort2 b, uint c);

int __ovld arm_dot_acc(short2 a, short2 b, int c);

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_accumulate_int16 : end

#endif // defined(cl_arm_integer_dot_product_accumulate_int16)


#if defined(cl_arm_integer_dot_product_accumulate_saturate_int8)

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_accumulate_saturate_int8 : begin

uint __ovld arm_dot_acc_sat(uchar4 a, uchar4 b, uint c);

int __ovld arm_dot_acc_sat(char4 a, char4 b, int c);

#pragma OPENCL EXTENSION cl_arm_integer_dot_product_accumulate_saturate_int8 : end

#endif // defined(cl_arm_integer_dot_product_accumulate_saturate_int8)


// Disable any extensions we may have enabled previously.

#pragma OPENCL EXTENSION all : disable


#undef __cnfn

#undef __ovld

#endif //_OPENCL_H_

uint8
etiss_uint8 uint8
Definition 386-GCC.h:76

int8
etiss_int8 int8
Definition 386-GCC.h:77

int16
etiss_int16 int16
Definition 386-GCC.h:79

uint16
etiss_uint16 uint16
Definition 386-GCC.h:78

b
__device__ __2f16 b
Definition __clang_hip_libdevice_declares.h:297

__attribute__
_Float16 __2f16 __attribute__((ext_vector_type(2)))
Zeroes the upper 128 bits (bits 255:128) of all YMM registers.
Definition __clang_hip_libdevice_declares.h:294

c
__device__ __2f16 float c
Definition __clang_hip_libdevice_declares.h:298

v
do v
Definition arm_acle.h:76

opencl-c-base.h

intptr_t
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type,...
Definition opencl-c-base.h:55

memory_order
memory_order
Definition opencl-c-base.h:305

uintptr_t
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition opencl-c-base.h:62

clk_profiling_info
int clk_profiling_info
Definition opencl-c-base.h:417

cl_mem_fence_flags
uint cl_mem_fence_flags
Definition opencl-c-base.h:265

uchar
unsigned char uchar
An unsigned 8-bit integer.
Definition opencl-c-base.h:17

ptrdiff_t
__PTRDIFF_TYPE__ ptrdiff_t
A signed integer type that is the result of subtracting two pointers.
Definition opencl-c-base.h:48

ulong
unsigned long ulong
An unsigned 64-bit integer.
Definition opencl-c-base.h:32

uint
unsigned int uint
An unsigned 32-bit integer.
Definition opencl-c-base.h:27

memory_scope
memory_scope
Definition opencl-c-base.h:281

ushort
unsigned short ushort
An unsigned 16-bit integer.
Definition opencl-c-base.h:22

convert_int4_rte
int4 __ovld __cnfn convert_int4_rte(char4)

convert_uint8_rte
uint8 __ovld __cnfn convert_uint8_rte(char8)

convert_long_rtp
long __ovld __cnfn convert_long_rtp(char)

convert_long2_sat_rtp
long2 __ovld __cnfn convert_long2_sat_rtp(char2)

vloada_half8
float8 __ovld vloada_half8(size_t offset, const __constant half *p)

vstorea_half3_rtz
void __ovld vstorea_half3_rtz(float3 data, size_t offset, half *p)

vstore_half_rtp
void __ovld vstore_half_rtp(float data, size_t offset, half *p)

bitselect
char __ovld __cnfn bitselect(char a, char b, char c)
Each bit of the result is the corresponding bit of a if the corresponding bit of c is 0.

convert_char2_rtp
char2 __ovld __cnfn convert_char2_rtp(char2)

convert_short8_sat_rte
short8 __ovld __cnfn convert_short8_sat_rte(char8)

convert_uchar8_rtp
uchar8 __ovld __cnfn convert_uchar8_rtp(char8)

convert_ulong16_sat
ulong16 __ovld __cnfn convert_ulong16_sat(char16)

vloada_half
float __ovld vloada_half(size_t offset, const __constant half *p)
For n = 1, 2, 4, 8 and 16 read sizeof (halfn) bytes of data from address (p + (offset * n)).

convert_uchar
uchar __ovld __cnfn convert_uchar(char)

convert_ulong8_rte
ulong8 __ovld __cnfn convert_ulong8_rte(char8)

vstorea_half8_rte
void __ovld vstorea_half8_rte(float8 data, size_t offset, half *p)

convert_int16_sat_rtn
int16 __ovld __cnfn convert_int16_sat_rtn(char16)

convert_int3_rtn
int3 __ovld __cnfn convert_int3_rtn(char3)

native_powr
float __ovld __cnfn native_powr(float x, float y)
Compute x to the power y, where x is >= 0.

convert_short4_rtp
short4 __ovld __cnfn convert_short4_rtp(char4)

vstore2
void __ovld vstore2(char2 data, size_t offset, char *p)

mul_hi
char __ovld __cnfn mul_hi(char x, char y)
Computes x * y and returns the high half of the product of x and y.

vstorea_half_rtp
void __ovld vstorea_half_rtp(float data, size_t offset, half *p)

convert_ulong2_rtn
ulong2 __ovld __cnfn convert_ulong2_rtn(char2)

convert_ushort8_rtn
ushort8 __ovld __cnfn convert_ushort8_rtn(char8)

vstorea_half2_rtz
void __ovld vstorea_half2_rtz(float2 data, size_t offset, half *p)

convert_uint16_sat_rtp
uint16 __ovld __cnfn convert_uint16_sat_rtp(char16)

acospi
float __ovld __cnfn acospi(float x)
Compute acos (x) / PI.

cross
float4 __ovld __cnfn cross(float4 p0, float4 p1)
Returns the cross product of p0.xyz and p1.xyz.

mad_sat
char __ovld __cnfn mad_sat(char a, char b, char c)
Returns a * b + c and saturates the result.

vload_half16
float16 __ovld vload_half16(size_t offset, const __constant half *p)

sub_sat
char __ovld __cnfn sub_sat(char x, char y)
Returns x - y and saturates the result.

convert_int3_rtp
int3 __ovld __cnfn convert_int3_rtp(char3)

convert_char3_sat
char3 __ovld __cnfn convert_char3_sat(char3)

convert_char4_sat
char4 __ovld __cnfn convert_char4_sat(char4)

convert_long_rtz
long __ovld __cnfn convert_long_rtz(char)

convert_ushort8_sat_rtn
ushort8 __ovld __cnfn convert_ushort8_sat_rtn(char8)

convert_uint_sat_rtn
uint __ovld __cnfn convert_uint_sat_rtn(char)

convert_uint16_sat_rtn
uint16 __ovld __cnfn convert_uint16_sat_rtn(char16)

convert_uchar8
uchar8 __ovld __cnfn convert_uchar8(char8)

half_sin
float __ovld __cnfn half_sin(float x)
Compute sine.

convert_uchar2_sat
uchar2 __ovld __cnfn convert_uchar2_sat(char2)

vstore_half2_rtz
void __ovld vstore_half2_rtz(float2 data, size_t offset, half *p)

radians
float __ovld __cnfn radians(float degrees)
Converts degrees to radians, i.e.

convert_int3
int3 __ovld __cnfn convert_int3(char3)

convert_short_sat_rtn
short __ovld __cnfn convert_short_sat_rtn(char)

get_global_size
size_t __ovld __cnfn get_global_size(uint dimindx)
Returns the number of global work-items specified for dimension identified by dimindx.

convert_uchar2_rte
uchar2 __ovld __cnfn convert_uchar2_rte(char2)

convert_uchar16_sat_rtn
uchar16 __ovld __cnfn convert_uchar16_sat_rtn(char16)

convert_ulong4_rtp
ulong4 __ovld __cnfn convert_ulong4_rtp(char4)

convert_ushort3_rtz
ushort3 __ovld __cnfn convert_ushort3_rtz(char3)

get_image_depth
int __ovld __cnfn get_image_depth(read_only image3d_t image)
Return the image depth in pixels.

convert_int16_sat
int16 __ovld __cnfn convert_int16_sat(char16)

vstore_half16_rte
void __ovld vstore_half16_rte(float16 data, size_t offset, half *p)

convert_char4_rte
char4 __ovld __cnfn convert_char4_rte(char4)

convert_int2_sat_rtz
int2 __ovld __cnfn convert_int2_sat_rtz(char2)

half_cos
float __ovld __cnfn half_cos(float x)
Compute cosine.

set_user_event_status
void __ovld set_user_event_status(clk_event_t e, int state)

mem_fence
void __ovld mem_fence(cl_mem_fence_flags flags)
Orders loads and stores of a work-item executing a kernel.

convert_float_rte
float __ovld __cnfn convert_float_rte(char)

islessequal
int __ovld __cnfn islessequal(float x, float y)
Returns the component-wise compare of x <= y.
Definition __clang_cuda_cmath.h:102

convert_ulong_rtz
ulong __ovld __cnfn convert_ulong_rtz(char)

convert_float2_rtp
float2 __ovld __cnfn convert_float2_rtp(char2)

convert_short4_sat_rtn
short4 __ovld __cnfn convert_short4_sat_rtn(char4)

convert_short2_rtz
short2 __ovld __cnfn convert_short2_rtz(char2)

write_imageui
void __ovld write_imageui(write_only image2d_t image, int2 coord, uint4 color)

convert_char8_sat_rte
char8 __ovld __cnfn convert_char8_sat_rte(char8)

maxmag
float __ovld __cnfn maxmag(float x, float y)
Returns x if | x | > | y |, y if | y | > | x |, otherwise fmax(x, y).

convert_ushort8_sat_rtp
ushort8 __ovld __cnfn convert_ushort8_sat_rtp(char8)

convert_int3_rtz
int3 __ovld __cnfn convert_int3_rtz(char3)

native_log
float __ovld __cnfn native_log(float x)
Compute natural logarithm over an implementationdefined range.

convert_ushort8_sat_rtz
ushort8 __ovld __cnfn convert_ushort8_sat_rtz(char8)

isnotequal
int __ovld __cnfn isnotequal(float x, float y)
Returns the component-wise compare of x != y.

convert_char8_sat_rtn
char8 __ovld __cnfn convert_char8_sat_rtn(char8)

convert_int2_sat
int2 __ovld __cnfn convert_int2_sat(char2)

atan2pi
float __ovld __cnfn atan2pi(float y, float x)
Compute atan2 (y, x) / PI.

normalize
float __ovld __cnfn normalize(float p)
Returns a vector in the same direction as p but with a length of 1.

distance
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.

vstore_half4_rtp
void __ovld vstore_half4_rtp(float4 data, size_t offset, half *p)

atomic_fetch_max_explicit
int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order)

vstore_half8
void __ovld vstore_half8(float8 data, size_t offset, half *p)

convert_ushort3_rtn
ushort3 __ovld __cnfn convert_ushort3_rtn(char3)

convert_float4
float4 __ovld __cnfn convert_float4(char4)

convert_ulong8_rtp
ulong8 __ovld __cnfn convert_ulong8_rtp(char8)

get_local_id
size_t __ovld __cnfn get_local_id(uint dimindx)
Returns the unique local work-item ID i.e.

convert_uint3_rtn
uint3 __ovld __cnfn convert_uint3_rtn(char3)

convert_ushort3_sat_rtn
ushort3 __ovld __cnfn convert_ushort3_sat_rtn(char3)

convert_long2_sat
long2 __ovld __cnfn convert_long2_sat(char2)

convert_ushort3_rte
ushort3 __ovld __cnfn convert_ushort3_rte(char3)

convert_ulong16_sat_rtp
ulong16 __ovld __cnfn convert_ulong16_sat_rtp(char16)

atomic_or
int __ovld atomic_or(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

vstore8
void __ovld vstore8(char8 data, size_t offset, char *p)

vload_half2
float2 __ovld vload_half2(size_t offset, const __constant half *p)
Read sizeof (halfn) bytes of data from address (p + (offset * n)).

convert_char8
char8 __ovld __cnfn convert_char8(char8)

printf
int printf(__constant const char *st,...) __attribute__((format(printf

convert_char_sat
char __ovld __cnfn convert_char_sat(char)

convert_ulong3_sat_rtn
ulong3 __ovld __cnfn convert_ulong3_sat_rtn(char3)

abs_diff
uchar __ovld __cnfn abs_diff(char x, char y)
Returns | x - y | without modulo overflow.

convert_ushort_rtn
ushort __ovld __cnfn convert_ushort_rtn(char)

convert_uint4_rtz
uint4 __ovld __cnfn convert_uint4_rtz(char4)

convert_float16_rtn
float16 __ovld __cnfn convert_float16_rtn(char16)

convert_short3_rtp
short3 __ovld __cnfn convert_short3_rtp(char3)

convert_int_sat_rtz
int __ovld __cnfn convert_int_sat_rtz(char)

sign
float __ovld __cnfn sign(float x)
Returns 1.0 if x > 0, -0.0 if x = -0.0, +0.0 if x = +0.0, or -1.0 if x < 0.

convert_int16
int16 __ovld __cnfn convert_int16(char16)

native_sin
float __ovld __cnfn native_sin(float x)
Compute sine over an implementation-defined range.

convert_uint_rtz
uint __ovld __cnfn convert_uint_rtz(char)

convert_ushort8_rte
ushort8 __ovld __cnfn convert_ushort8_rte(char8)

convert_long3_sat_rtz
long3 __ovld __cnfn convert_long3_sat_rtz(char3)

convert_short16_sat_rte
short16 __ovld __cnfn convert_short16_sat_rte(char16)

convert_ulong8_sat_rtn
ulong8 __ovld __cnfn convert_ulong8_sat_rtn(char8)

convert_ushort3_sat
ushort3 __ovld __cnfn convert_ushort3_sat(char3)

convert_int8_sat
int8 __ovld __cnfn convert_int8_sat(char8)

vstorea_half16
void __ovld vstorea_half16(float16 data, size_t offset, half *p)

convert_float3_rtp
float3 __ovld __cnfn convert_float3_rtp(char3)

convert_int16_rtp
int16 __ovld __cnfn convert_int16_rtp(char16)

half_recip
float __ovld __cnfn half_recip(float x)
Compute reciprocal.

vstore_half3_rtp
void __ovld vstore_half3_rtp(float3 data, size_t offset, half *p)

shuffle
char2 __ovld __cnfn shuffle(char2 x, uchar2 mask)
The shuffle and shuffle2 built-in functions construct a permutation of elements from one or two input...

vstore_half3_rtn
void __ovld vstore_half3_rtn(float3 data, size_t offset, half *p)

convert_ulong4_sat_rtn
ulong4 __ovld __cnfn convert_ulong4_sat_rtn(char4)

convert_uchar2_sat_rtp
uchar2 __ovld __cnfn convert_uchar2_sat_rtp(char2)

vload4
char4 __ovld vload4(size_t offset, const __constant char *p)

vstore16
void __ovld vstore16(char16 data, size_t offset, char *p)

abs
uchar __ovld __cnfn abs(char x)
Returns | x |.

vstorea_half_rte
void __ovld vstorea_half_rte(float data, size_t offset, half *p)

convert_ulong2_sat_rtz
ulong2 __ovld __cnfn convert_ulong2_sat_rtz(char2)

convert_int4_sat_rtz
int4 __ovld __cnfn convert_int4_sat_rtz(char4)

convert_ushort8_sat
ushort8 __ovld __cnfn convert_ushort8_sat(char8)

atomic_xchg
int __ovld atomic_xchg(volatile __global int *p, int val)
Swaps the old value stored at location p with new value given by val.

convert_uint3_sat
uint3 __ovld __cnfn convert_uint3_sat(char3)

vstorea_half4_rte
void __ovld vstorea_half4_rte(float4 data, size_t offset, half *p)

get_num_groups
size_t __ovld __cnfn get_num_groups(uint dimindx)
Returns the number of work-groups that will execute a kernel for dimension identified by dimindx.

write_mem_fence
void __ovld write_mem_fence(cl_mem_fence_flags flags)
Write memory barrier that orders only stores.

atomic_sub
int __ovld atomic_sub(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_ulong4_sat
ulong4 __ovld __cnfn convert_ulong4_sat(char4)

nan
float __ovld __cnfn nan(uint nancode)
Returns a quiet NaN.

convert_int16_sat_rtp
int16 __ovld __cnfn convert_int16_sat_rtp(char16)

convert_char16_sat_rtz
char16 __ovld __cnfn convert_char16_sat_rtz(char16)

convert_uint_sat
uint __ovld __cnfn convert_uint_sat(char)

convert_ushort4_sat_rtn
ushort4 __ovld __cnfn convert_ushort4_sat_rtn(char4)

vstore_half3_rtz
void __ovld vstore_half3_rtz(float3 data, size_t offset, half *p)

convert_float3_rtn
float3 __ovld __cnfn convert_float3_rtn(char3)

isgreater
int __ovld __cnfn isgreater(float x, float y)
Returns the component-wise compare of x > y.
Definition __clang_cuda_cmath.h:84

convert_long16
long16 __ovld __cnfn convert_long16(char16)

convert_short16_rtn
short16 __ovld __cnfn convert_short16_rtn(char16)

atanpi
float __ovld __cnfn atanpi(float x)
Compute atan (x) / PI.

rotate
char __ovld __cnfn rotate(char v, char i)
For each element in v, the bits are shifted left by the number of bits given by the corresponding ele...

convert_short2_rtp
short2 __ovld __cnfn convert_short2_rtp(char2)

convert_uchar8_rtz
uchar8 __ovld __cnfn convert_uchar8_rtz(char8)

native_recip
float __ovld __cnfn native_recip(float x)
Compute reciprocal over an implementation-defined range.

atomic_add
int __ovld atomic_add(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_int_rtz
int __ovld __cnfn convert_int_rtz(char)

convert_char16_rtz
char16 __ovld __cnfn convert_char16_rtz(char16)

convert_ushort16_rte
ushort16 __ovld __cnfn convert_ushort16_rte(char16)

convert_int2_sat_rtp
int2 __ovld __cnfn convert_int2_sat_rtp(char2)

native_rsqrt
float __ovld __cnfn native_rsqrt(float x)
Compute inverse square root over an implementationdefined range.

barrier
void __ovld __conv barrier(cl_mem_fence_flags flags)
All work-items in a work-group executing the kernel on a processor must execute this function before ...

convert_char_sat_rtn
char __ovld __cnfn convert_char_sat_rtn(char)

convert_short2
short2 __ovld __cnfn convert_short2(char2)

convert_short2_sat_rtp
short2 __ovld __cnfn convert_short2_sat_rtp(char2)

convert_int_rtn
int __ovld __cnfn convert_int_rtn(char)

convert_ushort_sat_rtz
ushort __ovld __cnfn convert_ushort_sat_rtz(char)

convert_long4
long4 __ovld __cnfn convert_long4(char4)

convert_short16_sat
short16 __ovld __cnfn convert_short16_sat(char16)

convert_uchar3_rtn
uchar3 __ovld __cnfn convert_uchar3_rtn(char3)

convert_short8
short8 __ovld __cnfn convert_short8(char8)

length
float __ovld __cnfn length(float p)
Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)

convert_ulong2_sat
ulong2 __ovld __cnfn convert_ulong2_sat(char2)

rootn
float __ovld __cnfn rootn(float x, int y)
Compute x to the power 1/y.

convert_ulong3_sat_rte
ulong3 __ovld __cnfn convert_ulong3_sat_rte(char3)

vstore_half2_rte
void __ovld vstore_half2_rte(float2 data, size_t offset, half *p)

convert_short4_sat_rte
short4 __ovld __cnfn convert_short4_sat_rte(char4)

sinpi
float __ovld __cnfn sinpi(float x)
Compute sin (PI * x).

convert_ulong8_sat
ulong8 __ovld __cnfn convert_ulong8_sat(char8)

convert_char2_sat_rtp
char2 __ovld __cnfn convert_char2_sat_rtp(char2)

convert_uint_sat_rte
uint __ovld __cnfn convert_uint_sat_rte(char)

convert_uint8_sat_rte
uint8 __ovld __cnfn convert_uint8_sat_rte(char8)

native_exp10
float __ovld __cnfn native_exp10(float x)
Compute the base- 10 exponential of x over an implementation-defined range.

convert_int16_rte
int16 __ovld __cnfn convert_int16_rte(char16)

convert_char16_sat_rtn
char16 __ovld __cnfn convert_char16_sat_rtn(char16)

convert_ulong_sat_rte
ulong __ovld __cnfn convert_ulong_sat_rte(char)

convert_float_rtp
float __ovld __cnfn convert_float_rtp(char)

convert_ulong2_sat_rtp
ulong2 __ovld __cnfn convert_ulong2_sat_rtp(char2)

convert_uint3_rtp
uint3 __ovld __cnfn convert_uint3_rtp(char3)

convert_float16_rtp
float16 __ovld __cnfn convert_float16_rtp(char16)

convert_short4_sat_rtz
short4 __ovld __cnfn convert_short4_sat_rtz(char4)

convert_int3_sat_rtz
int3 __ovld __cnfn convert_int3_sat_rtz(char3)

convert_ushort3_sat_rte
ushort3 __ovld __cnfn convert_ushort3_sat_rte(char3)

convert_ulong_sat
ulong __ovld __cnfn convert_ulong_sat(char)

convert_long3_sat
long3 __ovld __cnfn convert_long3_sat(char3)

convert_ulong4_sat_rtz
ulong4 __ovld __cnfn convert_ulong4_sat_rtz(char4)

convert_long8_sat_rte
long8 __ovld __cnfn convert_long8_sat_rte(char8)

convert_int4
int4 __ovld __cnfn convert_int4(char4)

convert_ushort8_rtz
ushort8 __ovld __cnfn convert_ushort8_rtz(char8)

convert_short_sat_rtp
short __ovld __cnfn convert_short_sat_rtp(char)

convert_ulong4_rtn
ulong4 __ovld __cnfn convert_ulong4_rtn(char4)

vstorea_half4
void __ovld vstorea_half4(float4 data, size_t offset, half *p)

convert_long16_rtn
long16 __ovld __cnfn convert_long16_rtn(char16)

convert_uint_rtn
uint __ovld __cnfn convert_uint_rtn(char)

convert_short2_rte
short2 __ovld __cnfn convert_short2_rte(char2)

vstore_half4_rte
void __ovld vstore_half4_rte(float4 data, size_t offset, half *p)

half_powr
float __ovld __cnfn half_powr(float x, float y)
Compute x to the power y, where x is >= 0.

convert_ulong3_rtp
ulong3 __ovld __cnfn convert_ulong3_rtp(char3)

clz
char __ovld __cnfn clz(char x)
Returns the number of leading 0-bits in x, starting at the most significant bit position.

convert_ulong16_rtz
ulong16 __ovld __cnfn convert_ulong16_rtz(char16)

convert_int2_rte
int2 __ovld __cnfn convert_int2_rte(char2)

vstorea_half16_rtz
void __ovld vstorea_half16_rtz(float16 data, size_t offset, half *p)

convert_float8_rte
float8 __ovld __cnfn convert_float8_rte(char8)

convert_uchar3
uchar3 __ovld __cnfn convert_uchar3(char3)

shuffle2
char2 __ovld __cnfn shuffle2(char2 x, char2 y, uchar2 mask)

convert_float_rtz
float __ovld __cnfn convert_float_rtz(char)

convert_char4_sat_rte
char4 __ovld __cnfn convert_char4_sat_rte(char4)

exp10
float __ovld __cnfn exp10(float)
Exponential base 10 function.

convert_char
char __ovld __cnfn convert_char(char)

convert_ushort16_sat_rte
ushort16 __ovld __cnfn convert_ushort16_sat_rte(char16)

vstorea_half8_rtp
void __ovld vstorea_half8_rtp(float8 data, size_t offset, half *p)

get_default_queue
queue_t __ovld get_default_queue(void)

isinf
int __ovld __cnfn isinf(float)
Test for infinity value (+ve or -ve) .
Definition __clang_cuda_cmath.h:73

atomic_fetch_max
int __ovld atomic_fetch_max(volatile atomic_int *object, int operand)

convert_ushort3_sat_rtz
ushort3 __ovld __cnfn convert_ushort3_sat_rtz(char3)

convert_short_rtp
short __ovld __cnfn convert_short_rtp(char)

wait_group_events
void __ovld wait_group_events(int num_events, event_t *event_list)
Wait for events that identify the async_work_group_copy operations to complete.

convert_uchar_rte
uchar __ovld __cnfn convert_uchar_rte(char)

release_event
void __ovld release_event(clk_event_t)

vload_half8
float8 __ovld vload_half8(size_t offset, const __constant half *p)

convert_float3_rtz
float3 __ovld __cnfn convert_float3_rtz(char3)

convert_long_rte
long __ovld __cnfn convert_long_rte(char)

vloada_half2
float2 __ovld vloada_half2(size_t offset, const __constant half *p)

convert_short8_rtz
short8 __ovld __cnfn convert_short8_rtz(char8)

get_global_linear_id
size_t __ovld get_global_linear_id(void)

convert_char_sat_rtz
char __ovld __cnfn convert_char_sat_rtz(char)

convert_int_rtp
int __ovld __cnfn convert_int_rtp(char)

convert_long3_sat_rtp
long3 __ovld __cnfn convert_long3_sat_rtp(char3)

convert_uchar_rtp
uchar __ovld __cnfn convert_uchar_rtp(char)

work_group_barrier
void __ovld __conv work_group_barrier(cl_mem_fence_flags flags, memory_scope scope)

convert_ulong4
ulong4 __ovld __cnfn convert_ulong4(char4)

convert_uint4_sat
uint4 __ovld __cnfn convert_uint4_sat(char4)

convert_ulong2
ulong2 __ovld __cnfn convert_ulong2(char2)

convert_long2_rtn
long2 __ovld __cnfn convert_long2_rtn(char2)

isequal
int __ovld __cnfn isequal(float x, float y)
intn isequal (floatn x, floatn y) Returns the component-wise compare of x == y.

convert_long16_rtp
long16 __ovld __cnfn convert_long16_rtp(char16)

vstorea_half8
void __ovld vstorea_half8(float8 data, size_t offset, half *p)

atomic_and
int __ovld atomic_and(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_ushort16_sat_rtn
ushort16 __ovld __cnfn convert_ushort16_sat_rtn(char16)

convert_long3_sat_rtn
long3 __ovld __cnfn convert_long3_sat_rtn(char3)

convert_uint2_rtp
uint2 __ovld __cnfn convert_uint2_rtp(char2)

convert_uint3
uint3 __ovld __cnfn convert_uint3(char3)

get_global_id
size_t __ovld __cnfn get_global_id(uint dimindx)
Returns the unique global work-item ID value for dimension identified by dimindx.

convert_ushort4_sat
ushort4 __ovld __cnfn convert_ushort4_sat(char4)

convert_short_rtz
short __ovld __cnfn convert_short_rtz(char)

convert_uint8_sat_rtn
uint8 __ovld __cnfn convert_uint8_sat_rtn(char8)

convert_uchar_sat
uchar __ovld __cnfn convert_uchar_sat(char)

convert_float8_rtn
float8 __ovld __cnfn convert_float8_rtn(char8)

convert_short4_sat
short4 __ovld __cnfn convert_short4_sat(char4)

convert_float4_rte
float4 __ovld __cnfn convert_float4_rte(char4)

convert_uchar4_rtz
uchar4 __ovld __cnfn convert_uchar4_rtz(char4)

convert_char4_rtp
char4 __ovld __cnfn convert_char4_rtp(char4)

convert_uchar16_sat
uchar16 __ovld __cnfn convert_uchar16_sat(char16)

convert_long8_sat_rtp
long8 __ovld __cnfn convert_long8_sat_rtp(char8)

convert_short3_rte
short3 __ovld __cnfn convert_short3_rte(char3)

convert_uint3_sat_rtz
uint3 __ovld __cnfn convert_uint3_sat_rtz(char3)

native_cos
float __ovld __cnfn native_cos(float x)
Compute cosine over an implementation-defined range.

capture_event_profiling_info
void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void *value)

convert_char3_sat_rtp
char3 __ovld __cnfn convert_char3_sat_rtp(char3)

isless
int __ovld __cnfn isless(float x, float y)
Returns the component-wise compare of x < y.
Definition __clang_cuda_cmath.h:96

half_log10
float __ovld __cnfn half_log10(float x)
Compute a base 10 logarithm.

convert_ushort16
ushort16 __ovld __cnfn convert_ushort16(char16)

half_exp2
float __ovld __cnfn half_exp2(float x)
Compute the base- 2 exponential of x.

native_exp2
float __ovld __cnfn native_exp2(float x)
Compute the base- 2 exponential of x over an implementation-defined range.

convert_long4_sat_rtp
long4 __ovld __cnfn convert_long4_sat_rtp(char4)

convert_uint8_rtn
uint8 __ovld __cnfn convert_uint8_rtn(char8)

get_global_offset
size_t __ovld __cnfn get_global_offset(uint dimindx)
get_global_offset returns the offset values specified in global_work_offset argument to clEnqueueNDRa...

work_group_scan_exclusive_min
int __ovld __conv work_group_scan_exclusive_min(int x)

vstore_half16_rtz
void __ovld vstore_half16_rtz(float16 data, size_t offset, half *p)

convert_float8
float8 __ovld __cnfn convert_float8(char8)

vstorea_half4_rtn
void __ovld vstorea_half4_rtn(float4 data, size_t offset, half *p)

any
int __ovld __cnfn any(char x)
Returns 1 if the most significant bit in any component of x is set; otherwise returns 0.

convert_float16
float16 __ovld __cnfn convert_float16(char16)

convert_char8_rtp
char8 __ovld __cnfn convert_char8_rtp(char8)

convert_short3_rtz
short3 __ovld __cnfn convert_short3_rtz(char3)

convert_char16_sat_rte
char16 __ovld __cnfn convert_char16_sat_rte(char16)

convert_long16_rte
long16 __ovld __cnfn convert_long16_rte(char16)

convert_uchar3_sat
uchar3 __ovld __cnfn convert_uchar3_sat(char3)

convert_uchar16_sat_rte
uchar16 __ovld __cnfn convert_uchar16_sat_rte(char16)

tanpi
float __ovld __cnfn tanpi(float x)
Compute tan (PI * x).

convert_long8_rtz
long8 __ovld __cnfn convert_long8_rtz(char8)

convert_ushort16_rtn
ushort16 __ovld __cnfn convert_ushort16_rtn(char16)

convert_ulong2_sat_rtn
ulong2 __ovld __cnfn convert_ulong2_sat_rtn(char2)

fast_distance
float __ovld __cnfn fast_distance(float p0, float p1)
Returns fast_length(p0 - p1).

half_log2
float __ovld __cnfn half_log2(float x)
Compute a base 2 logarithm.

convert_char4
char4 __ovld __cnfn convert_char4(char4)

convert_int2_rtz
int2 __ovld __cnfn convert_int2_rtz(char2)

convert_short16_sat_rtn
short16 __ovld __cnfn convert_short16_sat_rtn(char16)

convert_ulong_rtn
ulong __ovld __cnfn convert_ulong_rtn(char)

convert_ulong16_rtp
ulong16 __ovld __cnfn convert_ulong16_rtp(char16)

vstorea_half8_rtn
void __ovld vstorea_half8_rtn(float8 data, size_t offset, half *p)

minmag
float __ovld __cnfn minmag(float x, float y)
Returns x if | x | < | y |, y if | y | < | x |, otherwise fmin(x, y).

convert_char3_sat_rtn
char3 __ovld __cnfn convert_char3_sat_rtn(char3)

convert_short_rte
short __ovld __cnfn convert_short_rte(char)

convert_short3_sat
short3 __ovld __cnfn convert_short3_sat(char3)

convert_long8_sat
long8 __ovld __cnfn convert_long8_sat(char8)

convert_uint_sat_rtp
uint __ovld __cnfn convert_uint_sat_rtp(char)

convert_char2_sat_rte
char2 __ovld __cnfn convert_char2_sat_rte(char2)

convert_char4_sat_rtp
char4 __ovld __cnfn convert_char4_sat_rtp(char4)

convert_long8_rtp
long8 __ovld __cnfn convert_long8_rtp(char8)

convert_uint_rtp
uint __ovld __cnfn convert_uint_rtp(char)

convert_ulong
ulong __ovld __cnfn convert_ulong(char)

convert_short4_rtz
short4 __ovld __cnfn convert_short4_rtz(char4)

atomic_xor
int __ovld atomic_xor(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_uchar3_sat_rtn
uchar3 __ovld __cnfn convert_uchar3_sat_rtn(char3)

work_group_scan_exclusive_add
int __ovld __conv work_group_scan_exclusive_add(int x)

convert_ulong8_rtn
ulong8 __ovld __cnfn convert_ulong8_rtn(char8)

mad
float __ovld __cnfn mad(float a, float b, float c)
mad approximates a * b + c.

get_local_linear_id
size_t __ovld get_local_linear_id(void)

convert_short2_sat
short2 __ovld __cnfn convert_short2_sat(char2)

convert_char3_rtz
char3 __ovld __cnfn convert_char3_rtz(char3)

convert_uint2_sat_rtz
uint2 __ovld __cnfn convert_uint2_sat_rtz(char2)

work_group_scan_inclusive_max
int __ovld __conv work_group_scan_inclusive_max(int x)

convert_uchar4_sat_rte
uchar4 __ovld __cnfn convert_uchar4_sat_rte(char4)

convert_int8
int8 __ovld __cnfn convert_int8(char8)

convert_ulong16_rte
ulong16 __ovld __cnfn convert_ulong16_rte(char16)

convert_char16_rtp
char16 __ovld __cnfn convert_char16_rtp(char16)

convert_int16_sat_rte
int16 __ovld __cnfn convert_int16_sat_rte(char16)

convert_long16_sat
long16 __ovld __cnfn convert_long16_sat(char16)

convert_uchar_rtz
uchar __ovld __cnfn convert_uchar_rtz(char)

convert_char3_rtp
char3 __ovld __cnfn convert_char3_rtp(char3)

clamp
char __ovld __cnfn clamp(char x, char minval, char maxval)
Returns min(max(x, minval), maxval).

convert_int8_sat_rtp
int8 __ovld __cnfn convert_int8_sat_rtp(char8)

convert_ulong2_rte
ulong2 __ovld __cnfn convert_ulong2_rte(char2)

convert_char_rtz
char __ovld __cnfn convert_char_rtz(char)

work_group_scan_inclusive_min
int __ovld __conv work_group_scan_inclusive_min(int x)

convert_short16_sat_rtp
short16 __ovld __cnfn convert_short16_sat_rtp(char16)

convert_float4_rtz
float4 __ovld __cnfn convert_float4_rtz(char4)

convert_uint4_rtn
uint4 __ovld __cnfn convert_uint4_rtn(char4)

convert_float_rtn
float __ovld __cnfn convert_float_rtn(char)

rsqrt
float __ovld __cnfn rsqrt(float)
Compute inverse square root.

mad_hi
char __ovld __cnfn mad_hi(char a, char b, char c)
Returns mul_hi(a, b) + c.

min
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.

convert_float2_rte
float2 __ovld __cnfn convert_float2_rte(char2)

read_mem_fence
void __ovld read_mem_fence(cl_mem_fence_flags flags)
Read memory barrier that orders only loads.

step
float __ovld __cnfn step(float edge, float x)
Returns 0.0 if x < edge, otherwise it returns 1.0.

convert_ushort4_rtp
ushort4 __ovld __cnfn convert_ushort4_rtp(char4)

read_imagei
int4 __purefn __ovld read_imagei(read_only image2d_t image, sampler_t sampler, int2 coord)

convert_char3_rtn
char3 __ovld __cnfn convert_char3_rtn(char3)

convert_char3_sat_rte
char3 __ovld __cnfn convert_char3_sat_rte(char3)

atomic_max
int __ovld atomic_max(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_int_sat_rte
int __ovld __cnfn convert_int_sat_rte(char)

convert_short8_sat_rtz
short8 __ovld __cnfn convert_short8_sat_rtz(char8)

convert_uchar8_sat_rtp
uchar8 __ovld __cnfn convert_uchar8_sat_rtp(char8)

convert_uchar2
uchar2 __ovld __cnfn convert_uchar2(char2)

convert_uint4_rtp
uint4 __ovld __cnfn convert_uint4_rtp(char4)

convert_ushort4_rtz
ushort4 __ovld __cnfn convert_ushort4_rtz(char4)

convert_ushort_sat
ushort __ovld __cnfn convert_ushort_sat(char)

vstore3
void __ovld vstore3(char3 data, size_t offset, char *p)

convert_int3_sat_rtp
int3 __ovld __cnfn convert_int3_sat_rtp(char3)

convert_uint8_sat_rtp
uint8 __ovld __cnfn convert_uint8_sat_rtp(char8)

half_divide
float __ovld __cnfn half_divide(float x, float y)
Compute x / y.

convert_ulong8_rtz
ulong8 __ovld __cnfn convert_ulong8_rtz(char8)

convert_char4_sat_rtn
char4 __ovld __cnfn convert_char4_sat_rtn(char4)

convert_short_sat_rtz
short __ovld __cnfn convert_short_sat_rtz(char)

convert_ulong3_sat_rtp
ulong3 __ovld __cnfn convert_ulong3_sat_rtp(char3)

convert_uchar3_sat_rte
uchar3 __ovld __cnfn convert_uchar3_sat_rte(char3)

convert_ulong16_rtn
ulong16 __ovld __cnfn convert_ulong16_rtn(char16)

convert_char2_rte
char2 __ovld __cnfn convert_char2_rte(char2)

convert_uchar4_sat_rtn
uchar4 __ovld __cnfn convert_uchar4_sat_rtn(char4)

modf
float __ovld modf(float x, float *iptr)
Decompose a floating-point number.
Definition __clang_cuda_cmath.h:127

convert_char4_sat_rtz
char4 __ovld __cnfn convert_char4_sat_rtz(char4)

convert_short3_sat_rtp
short3 __ovld __cnfn convert_short3_sat_rtp(char3)

convert_ushort2_sat
ushort2 __ovld __cnfn convert_ushort2_sat(char2)

convert_float8_rtz
float8 __ovld __cnfn convert_float8_rtz(char8)

retain_event
void __ovld retain_event(clk_event_t)

convert_short3_sat_rte
short3 __ovld __cnfn convert_short3_sat_rte(char3)

convert_char8_sat_rtz
char8 __ovld __cnfn convert_char8_sat_rtz(char8)

convert_uchar2_rtp
uchar2 __ovld __cnfn convert_uchar2_rtp(char2)

work_group_any
int __ovld __conv work_group_any(int predicate)

convert_ushort16_sat_rtz
ushort16 __ovld __cnfn convert_ushort16_sat_rtz(char16)

convert_uint4_sat_rte
uint4 __ovld __cnfn convert_uint4_sat_rte(char4)

lgamma_r
float __ovld lgamma_r(float x, int *signp)

convert_short16_sat_rtz
short16 __ovld __cnfn convert_short16_sat_rtz(char16)

convert_uchar3_rtp
uchar3 __ovld __cnfn convert_uchar3_rtp(char3)

convert_ushort4_sat_rtz
ushort4 __ovld __cnfn convert_ushort4_sat_rtz(char4)

read_imagef
int float4 __purefn __ovld read_imagef(read_only image2d_t image, sampler_t sampler, int2 coord)
Use the coordinate (coord.xy) to do an element lookup in the 2D image object specified by image.

vstore_half8_rte
void __ovld vstore_half8_rte(float8 data, size_t offset, half *p)

popcount
char __ovld __cnfn popcount(char x)

convert_uint3_rtz
uint3 __ovld __cnfn convert_uint3_rtz(char3)

vstore_half4
void __ovld vstore_half4(float4 data, size_t offset, half *p)

convert_uint8_sat
uint8 __ovld __cnfn convert_uint8_sat(char8)

convert_uchar2_sat_rtn
uchar2 __ovld __cnfn convert_uchar2_sat_rtn(char2)

work_group_scan_exclusive_max
int __ovld __conv work_group_scan_exclusive_max(int x)

vload_half3
float3 __ovld vload_half3(size_t offset, const __constant half *p)

fast_normalize
float __ovld __cnfn fast_normalize(float p)
Returns a vector in the same direction as p but with a length of 1.

convert_ushort2_rtz
ushort2 __ovld __cnfn convert_ushort2_rtz(char2)

isfinite
int __ovld __cnfn isfinite(float)
Test for finite value.
Definition __clang_cuda_cmath.h:75

native_tan
float __ovld __cnfn native_tan(float x)
Compute tangent over an implementation-defined range.

half_tan
float __ovld __cnfn half_tan(float x)
Compute tangent.

convert_float3
float3 __ovld __cnfn convert_float3(char3)

half_rsqrt
float __ovld __cnfn half_rsqrt(float x)
Compute inverse square root.

convert_int4_sat_rte
int4 __ovld __cnfn convert_int4_sat_rte(char4)

convert_char8_rtz
char8 __ovld __cnfn convert_char8_rtz(char8)

convert_short4_sat_rtp
short4 __ovld __cnfn convert_short4_sat_rtp(char4)

native_exp
float __ovld __cnfn native_exp(float x)
Compute the base- e exponential of x over an implementation-defined range.

pown
float __ovld __cnfn pown(float x, int y)
Compute x to the power y, where y is an integer.

convert_int2_rtp
int2 __ovld __cnfn convert_int2_rtp(char2)

convert_long4_sat_rtn
long4 __ovld __cnfn convert_long4_sat_rtn(char4)

convert_int16_sat_rtz
int16 __ovld __cnfn convert_int16_sat_rtz(char16)

write_imagef
void __ovld write_imagef(write_only image2d_t image, int2 coord, float4 color)
Write color value to location specified by coordinate (coord.x, coord.y) in the 2D image object speci...

convert_uchar4_sat
uchar4 __ovld __cnfn convert_uchar4_sat(char4)

convert_ushort_rtz
ushort __ovld __cnfn convert_ushort_rtz(char)

convert_short8_rtp
short8 __ovld __cnfn convert_short8_rtp(char8)

convert_long4_rtn
long4 __ovld __cnfn convert_long4_rtn(char4)

vstore4
void __ovld vstore4(char4 data, size_t offset, char *p)

convert_int4_sat_rtn
int4 __ovld __cnfn convert_int4_sat_rtn(char4)

max
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.

convert_long
long __ovld __cnfn convert_long(char)

convert_short8_rte
short8 __ovld __cnfn convert_short8_rte(char8)

vstore_half3
void __ovld vstore_half3(float3 data, size_t offset, half *p)

convert_char16_rte
char16 __ovld __cnfn convert_char16_rte(char16)

convert_int3_sat_rte
int3 __ovld __cnfn convert_int3_sat_rte(char3)

enqueue_marker
int __ovld enqueue_marker(queue_t, uint, const clk_event_t *, clk_event_t *)

convert_ushort2_sat_rtz
ushort2 __ovld __cnfn convert_ushort2_sat_rtz(char2)

convert_short4_rtn
short4 __ovld __cnfn convert_short4_rtn(char4)

convert_float2
float2 __ovld __cnfn convert_float2(char2)

convert_long2_rtz
long2 __ovld __cnfn convert_long2_rtz(char2)

convert_char_sat_rtp
char __ovld __cnfn convert_char_sat_rtp(char)

work_group_broadcast
int __ovld __conv work_group_broadcast(int a, size_t local_id)

convert_uint16_rtz
uint16 __ovld __cnfn convert_uint16_rtz(char16)

convert_short3_sat_rtn
short3 __ovld __cnfn convert_short3_sat_rtn(char3)

convert_uchar16
uchar16 __ovld __cnfn convert_uchar16(char16)

convert_uint3_rte
uint3 __ovld __cnfn convert_uint3_rte(char3)

convert_uint16_sat_rte
uint16 __ovld __cnfn convert_uint16_sat_rte(char16)

convert_long3_rtp
long3 __ovld __cnfn convert_long3_rtp(char3)

isnormal
int __ovld __cnfn isnormal(float)
Test for a normal value.
Definition __clang_cuda_cmath.h:114

convert_ushort2_rtn
ushort2 __ovld __cnfn convert_ushort2_rtn(char2)

convert_char8_sat
char8 __ovld __cnfn convert_char8_sat(char8)

convert_uint16_rtn
uint16 __ovld __cnfn convert_uint16_rtn(char16)

convert_long8_sat_rtn
long8 __ovld __cnfn convert_long8_sat_rtn(char8)

convert_uchar8_sat_rtn
uchar8 __ovld __cnfn convert_uchar8_sat_rtn(char8)

convert_uchar8_rte
uchar8 __ovld __cnfn convert_uchar8_rte(char8)

convert_uint4_sat_rtz
uint4 __ovld __cnfn convert_uint4_sat_rtz(char4)

native_sqrt
float __ovld __cnfn native_sqrt(float x)
Compute square root over an implementation-defined range.

convert_int16_rtn
int16 __ovld __cnfn convert_int16_rtn(char16)

convert_int4_rtz
int4 __ovld __cnfn convert_int4_rtz(char4)

vstorea_half4_rtz
void __ovld vstorea_half4_rtz(float4 data, size_t offset, half *p)

async_work_group_strided_copy
event_t __ovld async_work_group_strided_copy(__local char *dst, const __global char *src, size_t num_elements, size_t src_stride, event_t event)
Perform an async gather of num_elements gentype elements from src to dst.

vstorea_half4_rtp
void __ovld vstorea_half4_rtp(float4 data, size_t offset, half *p)

convert_uint2_rte
uint2 __ovld __cnfn convert_uint2_rte(char2)

convert_ulong16
ulong16 __ovld __cnfn convert_ulong16(char16)

atomic_dec
int __ovld atomic_dec(volatile __global int *p)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_char_rtp
char __ovld __cnfn convert_char_rtp(char)

convert_uchar8_sat_rtz
uchar8 __ovld __cnfn convert_uchar8_sat_rtz(char8)

convert_ulong3
ulong3 __ovld __cnfn convert_ulong3(char3)

convert_char3
char3 __ovld __cnfn convert_char3(char3)

get_image_height
int __ovld __cnfn get_image_height(read_only image2d_t image)
Return the image height in pixels.

convert_long_sat_rtz
long __ovld __cnfn convert_long_sat_rtz(char)

vstorea_half16_rtp
void __ovld vstorea_half16_rtp(float16 data, size_t offset, half *p)

convert_long2_sat_rtz
long2 __ovld __cnfn convert_long2_sat_rtz(char2)

convert_ulong4_sat_rte
ulong4 __ovld __cnfn convert_ulong4_sat_rte(char4)

convert_char2_rtn
char2 __ovld __cnfn convert_char2_rtn(char2)

convert_short2_sat_rtz
short2 __ovld __cnfn convert_short2_sat_rtz(char2)

convert_short8_sat_rtn
short8 __ovld __cnfn convert_short8_sat_rtn(char8)

convert_uint2_sat_rtn
uint2 __ovld __cnfn convert_uint2_sat_rtn(char2)

convert_uchar3_rtz
uchar3 __ovld __cnfn convert_uchar3_rtz(char3)

native_divide
float __ovld __cnfn native_divide(float x, float y)
Compute x / y over an implementation-defined range.

atomic_work_item_fence
void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope)

convert_uint3_sat_rtn
uint3 __ovld __cnfn convert_uint3_sat_rtn(char3)

vloada_half4
float4 __ovld vloada_half4(size_t offset, const __constant half *p)

convert_uchar4_rtn
uchar4 __ovld __cnfn convert_uchar4_rtn(char4)

convert_uint4_sat_rtn
uint4 __ovld __cnfn convert_uint4_sat_rtn(char4)

convert_int8_sat_rte
int8 __ovld __cnfn convert_int8_sat_rte(char8)

convert_ulong3_sat
ulong3 __ovld __cnfn convert_ulong3_sat(char3)

convert_ushort3_rtp
ushort3 __ovld __cnfn convert_ushort3_rtp(char3)

convert_float3_rte
float3 __ovld __cnfn convert_float3_rte(char3)

convert_uchar_rtn
uchar __ovld __cnfn convert_uchar_rtn(char)

convert_long4_sat_rte
long4 __ovld __cnfn convert_long4_sat_rte(char4)

convert_int3_sat_rtn
int3 __ovld __cnfn convert_int3_sat_rtn(char3)

convert_long_rtn
long __ovld __cnfn convert_long_rtn(char)

convert_uchar8_sat_rte
uchar8 __ovld __cnfn convert_uchar8_sat_rte(char8)

convert_long2
long2 __ovld __cnfn convert_long2(char2)

fract
float __ovld fract(float x, float *iptr)
Returns fmin(x - floor (x), 0x1.fffffep-1f ).

convert_ulong16_sat_rte
ulong16 __ovld __cnfn convert_ulong16_sat_rte(char16)

convert_long_sat
long __ovld __cnfn convert_long_sat(char)

convert_short_sat_rte
short __ovld __cnfn convert_short_sat_rte(char)

ndrange_2D
ndrange_t __ovld ndrange_2D(const size_t[2])

ndrange_1D
ndrange_t __ovld ndrange_1D(size_t)

convert_ulong16_sat_rtz
ulong16 __ovld __cnfn convert_ulong16_sat_rtz(char16)

convert_ushort_sat_rte
ushort __ovld __cnfn convert_ushort_sat_rte(char)

convert_short2_sat_rte
short2 __ovld __cnfn convert_short2_sat_rte(char2)

get_group_id
size_t __ovld __cnfn get_group_id(uint dimindx)
get_group_id returns the work-group ID which is a number from 0 .

convert_uint8
uint8 __ovld __cnfn convert_uint8(char8)

half_sqrt
float __ovld __cnfn half_sqrt(float x)
Compute square root.

get_work_dim
uint __ovld __cnfn get_work_dim(void)
Returns the number of dimensions in use.

convert_long2_sat_rtn
long2 __ovld __cnfn convert_long2_sat_rtn(char2)

convert_int2_rtn
int2 __ovld __cnfn convert_int2_rtn(char2)

rhadd
char __ovld __cnfn rhadd(char x, char y)
Returns (x + y + 1) >> 1.

convert_long8_rte
long8 __ovld __cnfn convert_long8_rte(char8)

convert_char16_sat_rtp
char16 __ovld __cnfn convert_char16_sat_rtp(char16)

convert_uchar_sat_rte
uchar __ovld __cnfn convert_uchar_sat_rte(char)

convert_uchar4
uchar4 __ovld __cnfn convert_uchar4(char4)

convert_uchar8_rtn
uchar8 __ovld __cnfn convert_uchar8_rtn(char8)

isgreaterequal
int __ovld __cnfn isgreaterequal(float x, float y)
Returns the component-wise compare of x >= y.
Definition __clang_cuda_cmath.h:90

vstorea_half_rtz
void __ovld vstorea_half_rtz(float data, size_t offset, half *p)

half_exp
float __ovld __cnfn half_exp(float x)
Compute the base- e exponential of x.

work_group_reduce_min
int __ovld __conv work_group_reduce_min(int x)

convert_ushort8_rtp
ushort8 __ovld __cnfn convert_ushort8_rtp(char8)

convert_float4_rtp
float4 __ovld __cnfn convert_float4_rtp(char4)

vstorea_half3_rte
void __ovld vstorea_half3_rte(float3 data, size_t offset, half *p)

convert_uint2_sat_rtp
uint2 __ovld __cnfn convert_uint2_sat_rtp(char2)

convert_long8_rtn
long8 __ovld __cnfn convert_long8_rtn(char8)

all
int __ovld __cnfn all(char x)
Returns 1 if the most significant bit in all components of x is set; otherwise returns 0.

get_image_dim
int2 __ovld __cnfn get_image_dim(read_only image2d_t image)
Return the 2D image width and height as an int2 type.

convert_char2_rtz
char2 __ovld __cnfn convert_char2_rtz(char2)

convert_ulong4_rtz
ulong4 __ovld __cnfn convert_ulong4_rtz(char4)

convert_ushort3_sat_rtp
ushort3 __ovld __cnfn convert_ushort3_sat_rtp(char3)

isunordered
int __ovld __cnfn isunordered(float x, float y)
Test if arguments are unordered.
Definition __clang_cuda_cmath.h:116

convert_long16_sat_rtp
long16 __ovld __cnfn convert_long16_sat_rtp(char16)

convert_uchar_sat_rtn
uchar __ovld __cnfn convert_uchar_sat_rtn(char)

convert_ushort4_sat_rtp
ushort4 __ovld __cnfn convert_ushort4_sat_rtp(char4)

convert_uchar_sat_rtz
uchar __ovld __cnfn convert_uchar_sat_rtz(char)

convert_long4_rtp
long4 __ovld __cnfn convert_long4_rtp(char4)

convert_ushort3
ushort3 __ovld __cnfn convert_ushort3(char3)

convert_long2_rtp
long2 __ovld __cnfn convert_long2_rtp(char2)

convert_char4_rtz
char4 __ovld __cnfn convert_char4_rtz(char4)

convert_uchar4_rtp
uchar4 __ovld __cnfn convert_uchar4_rtp(char4)

convert_int_sat_rtn
int __ovld __cnfn convert_int_sat_rtn(char)

convert_uchar16_rtz
uchar16 __ovld __cnfn convert_uchar16_rtz(char16)

atomic_fetch_min_explicit
int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order)

convert_char2
char2 __ovld __cnfn convert_char2(char2)

vstorea_half2
void __ovld vstorea_half2(float2 data, size_t offset, half *p)

select
char __ovld __cnfn select(char a, char b, char c)
For each component of a vector type, result[i] = if MSB of c[i] is set ? b[i] : a[i].

convert_long4_rtz
long4 __ovld __cnfn convert_long4_rtz(char4)

convert_char_rte
char __ovld __cnfn convert_char_rte(char)

convert_ushort
ushort __ovld __cnfn convert_ushort(char)

convert_uint8_rtp
uint8 __ovld __cnfn convert_uint8_rtp(char8)

convert_long16_rtz
long16 __ovld __cnfn convert_long16_rtz(char16)

mul24
int __ovld __cnfn mul24(int x, int y)
Multiply two 24-bit integer values x and y.

convert_ushort8_sat_rte
ushort8 __ovld __cnfn convert_ushort8_sat_rte(char8)

convert_short16_rtp
short16 __ovld __cnfn convert_short16_rtp(char16)

vload2
char2 __ovld vload2(size_t offset, const __constant char *p)
Use generic type gentype to indicate the built-in data types char, uchar, short, ushort,...

convert_long4_sat
long4 __ovld __cnfn convert_long4_sat(char4)

convert_long4_rte
long4 __ovld __cnfn convert_long4_rte(char4)

async_work_group_copy
event_t __ovld async_work_group_copy(__local char *dst, const __global char *src, size_t num_elements, event_t event)
Builtin functions to_global, to_local, and to_private need to be declared as Clang builtin functions ...

powr
float __ovld __cnfn powr(float x, float y)
Compute x to the power y, where x is >= 0.

convert_char8_rtn
char8 __ovld __cnfn convert_char8_rtn(char8)

convert_short3
short3 __ovld __cnfn convert_short3(char3)

convert_int8_sat_rtn
int8 __ovld __cnfn convert_int8_sat_rtn(char8)

convert_char3_sat_rtz
char3 __ovld __cnfn convert_char3_sat_rtz(char3)

convert_ulong8
ulong8 __ovld __cnfn convert_ulong8(char8)

convert_uchar3_sat_rtz
uchar3 __ovld __cnfn convert_uchar3_sat_rtz(char3)

is_valid_event
bool __ovld is_valid_event(clk_event_t event)

vstore_half2
void __ovld vstore_half2(float2 data, size_t offset, half *p)
The floatn value given by data is converted to a halfn value using the appropriate rounding mode.

vstorea_half2_rtp
void __ovld vstorea_half2_rtp(float2 data, size_t offset, half *p)

work_group_scan_inclusive_add
int __ovld __conv work_group_scan_inclusive_add(int x)

convert_long3_rte
long3 __ovld __cnfn convert_long3_rte(char3)

convert_char8_sat_rtp
char8 __ovld __cnfn convert_char8_sat_rtp(char8)

convert_char_rtn
char __ovld __cnfn convert_char_rtn(char)

convert_long3_sat_rte
long3 __ovld __cnfn convert_long3_sat_rte(char3)

convert_char_sat_rte
char __ovld __cnfn convert_char_sat_rte(char)

vstorea_half_rtn
void __ovld vstorea_half_rtn(float data, size_t offset, half *p)

vstore_half8_rtp
void __ovld vstore_half8_rtp(float8 data, size_t offset, half *p)

convert_ulong16_sat_rtn
ulong16 __ovld __cnfn convert_ulong16_sat_rtn(char16)

convert_uint2_rtz
uint2 __ovld __cnfn convert_uint2_rtz(char2)

convert_long_sat_rte
long __ovld __cnfn convert_long_sat_rte(char)

convert_int2
int2 __ovld __cnfn convert_int2(char2)

isnan
int __ovld __cnfn isnan(float)
Test for a NaN.
Definition __clang_cuda_cmath.h:80

vstore_half8_rtn
void __ovld vstore_half8_rtn(float8 data, size_t offset, half *p)

__ovld
#define __ovld
Definition opencl-c.h:31

convert_short3_rtn
short3 __ovld __cnfn convert_short3_rtn(char3)

convert_int2_sat_rtn
int2 __ovld __cnfn convert_int2_sat_rtn(char2)

convert_short_rtn
short __ovld __cnfn convert_short_rtn(char)

convert_ulong2_rtz
ulong2 __ovld __cnfn convert_ulong2_rtz(char2)

convert_uint2_sat
uint2 __ovld __cnfn convert_uint2_sat(char2)

convert_int4_sat_rtp
int4 __ovld __cnfn convert_int4_sat_rtp(char4)

convert_uchar16_sat_rtp
uchar16 __ovld __cnfn convert_uchar16_sat_rtp(char16)

convert_short3_sat_rtz
short3 __ovld __cnfn convert_short3_sat_rtz(char3)

native_log10
float __ovld __cnfn native_log10(float x)
Compute a base 10 logarithm over an implementationdefined range.

convert_uint2_rtn
uint2 __ovld __cnfn convert_uint2_rtn(char2)

convert_int_rte
int __ovld __cnfn convert_int_rte(char)

convert_int8_rte
int8 __ovld __cnfn convert_int8_rte(char8)

convert_uchar_sat_rtp
uchar __ovld __cnfn convert_uchar_sat_rtp(char)

convert_ulong3_sat_rtz
ulong3 __ovld __cnfn convert_ulong3_sat_rtz(char3)

vstorea_half
void __ovld vstorea_half(float data, size_t offset, half *p)
The floatn value given by data is converted to a halfn value using the appropriate rounding mode.

convert_ushort2_sat_rtp
ushort2 __ovld __cnfn convert_ushort2_sat_rtp(char2)

convert_uchar2_rtz
uchar2 __ovld __cnfn convert_uchar2_rtz(char2)

convert_int
int __ovld __cnfn convert_int(char)

prefetch
void __ovld prefetch(const __global char *p, size_t num_elements)
Prefetch num_elements * sizeof(gentype) bytes into the global cache.

convert_ushort16_rtp
ushort16 __ovld __cnfn convert_ushort16_rtp(char16)

convert_ulong4_sat_rtp
ulong4 __ovld __cnfn convert_ulong4_sat_rtp(char4)

convert_int4_rtp
int4 __ovld __cnfn convert_int4_rtp(char4)

vstorea_half8_rtz
void __ovld vstorea_half8_rtz(float8 data, size_t offset, half *p)

half_exp10
float __ovld __cnfn half_exp10(float x)
Compute the base- 10 exponential of x.

ndrange_3D
ndrange_t __ovld ndrange_3D(const size_t[3])

read_imageui
uint4 __purefn __ovld read_imageui(read_only image2d_t image, sampler_t sampler, int2 coord)

native_log2
float __ovld __cnfn native_log2(float x)
Compute a base 2 logarithm over an implementationdefined range.

convert_ulong_sat_rtp
ulong __ovld __cnfn convert_ulong_sat_rtp(char)

convert_short2_rtn
short2 __ovld __cnfn convert_short2_rtn(char2)

sincos
float __ovld sincos(float x, float *cosval)
Compute sine and cosine of x.

get_image_channel_data_type
int __ovld __cnfn get_image_channel_data_type(read_only image1d_t image)
Return the channel data type.

vstore_half_rtz
void __ovld vstore_half_rtz(float data, size_t offset, half *p)

vstorea_half16_rtn
void __ovld vstorea_half16_rtn(float16 data, size_t offset, half *p)

convert_int16_rtz
int16 __ovld __cnfn convert_int16_rtz(char16)

convert_ulong_sat_rtz
ulong __ovld __cnfn convert_ulong_sat_rtz(char)

half_log
float __ovld __cnfn half_log(float x)
Compute natural logarithm.

convert_long8
long8 __ovld __cnfn convert_long8(char8)

convert_uchar3_rte
uchar3 __ovld __cnfn convert_uchar3_rte(char3)

islessgreater
int __ovld __cnfn islessgreater(float x, float y)
Returns the component-wise compare of (x < y) || (x > y) .
Definition __clang_cuda_cmath.h:108

convert_long_sat_rtn
long __ovld __cnfn convert_long_sat_rtn(char)

convert_uchar2_sat_rte
uchar2 __ovld __cnfn convert_uchar2_sat_rte(char2)

convert_ushort16_sat_rtp
ushort16 __ovld __cnfn convert_ushort16_sat_rtp(char16)

convert_ushort16_rtz
ushort16 __ovld __cnfn convert_ushort16_rtz(char16)

convert_ushort2_sat_rtn
ushort2 __ovld __cnfn convert_ushort2_sat_rtn(char2)

vload8
char8 __ovld vload8(size_t offset, const __constant char *p)

convert_int8_sat_rtz
int8 __ovld __cnfn convert_int8_sat_rtz(char8)

convert_long16_sat_rte
long16 __ovld __cnfn convert_long16_sat_rte(char16)

convert_uchar16_rtp
uchar16 __ovld __cnfn convert_uchar16_rtp(char16)

get_enqueued_local_size
size_t __ovld get_enqueued_local_size(uint dimindx)

convert_uchar2_rtn
uchar2 __ovld __cnfn convert_uchar2_rtn(char2)

signbit
int __ovld __cnfn signbit(float)
Test for sign bit.
Definition __clang_cuda_cmath.h:137

convert_short16_rte
short16 __ovld __cnfn convert_short16_rte(char16)

vstore_half_rtn
void __ovld vstore_half_rtn(float data, size_t offset, half *p)

convert_ulong8_sat_rtp
ulong8 __ovld __cnfn convert_ulong8_sat_rtp(char8)

vload_half
float __ovld vload_half(size_t offset, const __constant half *p)
Read sizeof (half) bytes of data from address (p + offset).

convert_long8_sat_rtz
long8 __ovld __cnfn convert_long8_sat_rtz(char8)

get_image_width
int __ovld __cnfn get_image_width(read_only image1d_t image)
Return the image width in pixels.

upsample
short __ovld __cnfn upsample(char hi, uchar lo)
result[i] = ((short)hi[i] << 8) | lo[i] result[i] = ((ushort)hi[i] << 8) | lo[i]

convert_short8_sat
short8 __ovld __cnfn convert_short8_sat(char8)

vstore_half2_rtp
void __ovld vstore_half2_rtp(float2 data, size_t offset, half *p)

convert_float2_rtn
float2 __ovld __cnfn convert_float2_rtn(char2)

vstore_half16
void __ovld vstore_half16(float16 data, size_t offset, half *p)

convert_ulong3_rtn
ulong3 __ovld __cnfn convert_ulong3_rtn(char3)

__cnfn
#define __cnfn
Definition opencl-c.h:36

convert_char4_rtn
char4 __ovld __cnfn convert_char4_rtn(char4)

vstorea_half3
void __ovld vstorea_half3(float3 data, size_t offset, half *p)

convert_int3_rte
int3 __ovld __cnfn convert_int3_rte(char3)

convert_int2_sat_rte
int2 __ovld __cnfn convert_int2_sat_rte(char2)

is_valid_reserve_id
bool __ovld is_valid_reserve_id(reserve_id_t reserve_id)

convert_long4_sat_rtz
long4 __ovld __cnfn convert_long4_sat_rtz(char4)

convert_ulong_rte
ulong __ovld __cnfn convert_ulong_rte(char)

convert_float16_rtz
float16 __ovld __cnfn convert_float16_rtz(char16)

vstore_half16_rtn
void __ovld vstore_half16_rtn(float16 data, size_t offset, half *p)

convert_ulong8_sat_rtz
ulong8 __ovld __cnfn convert_ulong8_sat_rtz(char8)

convert_uint_rte
uint __ovld __cnfn convert_uint_rte(char)

convert_uchar4_sat_rtz
uchar4 __ovld __cnfn convert_uchar4_sat_rtz(char4)

work_group_reduce_max
int __ovld __conv work_group_reduce_max(int x)

convert_long3
long3 __ovld __cnfn convert_long3(char3)

convert_short8_sat_rtp
short8 __ovld __cnfn convert_short8_sat_rtp(char8)

convert_uint16
uint16 __ovld __cnfn convert_uint16(char16)

vloada_half16
float16 __ovld vloada_half16(size_t offset, const __constant half *p)

convert_short16
short16 __ovld __cnfn convert_short16(char16)

vstore_half3_rte
void __ovld vstore_half3_rte(float3 data, size_t offset, half *p)

convert_long_sat_rtp
long __ovld __cnfn convert_long_sat_rtp(char)

vload16
char16 __ovld vload16(size_t offset, const __constant char *p)

convert_long3_rtz
long3 __ovld __cnfn convert_long3_rtz(char3)

vstorea_half2_rte
void __ovld vstorea_half2_rte(float2 data, size_t offset, half *p)

convert_char16_sat
char16 __ovld __cnfn convert_char16_sat(char16)

convert_short4_rte
short4 __ovld __cnfn convert_short4_rte(char4)

asinpi
float __ovld __cnfn asinpi(float x)
Compute asin (x) / PI.

convert_float
float __ovld __cnfn convert_float(char)

convert_int4_sat
int4 __ovld __cnfn convert_int4_sat(char4)

convert_long16_sat_rtz
long16 __ovld __cnfn convert_long16_sat_rtz(char16)

convert_uchar16_rte
uchar16 __ovld __cnfn convert_uchar16_rte(char16)

convert_int8_rtp
int8 __ovld __cnfn convert_int8_rtp(char8)

atomic_min
int __ovld atomic_min(volatile __global int *p, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

get_image_array_size
size_t __ovld __cnfn get_image_array_size(read_only image1d_array_t image_array)
Return the image array size.

vload3
char3 __ovld vload3(size_t offset, const __constant char *p)

atomic_cmpxchg
int __ovld atomic_cmpxchg(volatile __global int *p, int cmp, int val)
Read the 32-bit value (referred to as old) stored at location pointed by p.

convert_uint16_rtp
uint16 __ovld __cnfn convert_uint16_rtp(char16)

hadd
char __ovld __cnfn hadd(char x, char y)
Returns (x + y) >> 1.

convert_ushort_rte
ushort __ovld __cnfn convert_ushort_rte(char)

convert_long2_sat_rte
long2 __ovld __cnfn convert_long2_sat_rte(char2)

convert_long16_sat_rtn
long16 __ovld __cnfn convert_long16_sat_rtn(char16)

vstore_half
void __ovld vstore_half(float data, size_t offset, half *p)
The float value given by data is first converted to a half value using the appropriate rounding mode.

convert_ulong2_sat_rte
ulong2 __ovld __cnfn convert_ulong2_sat_rte(char2)

convert_uchar16_sat_rtz
uchar16 __ovld __cnfn convert_uchar16_sat_rtz(char16)

convert_uchar4_sat_rtp
uchar4 __ovld __cnfn convert_uchar4_sat_rtp(char4)

convert_ulong4_rte
ulong4 __ovld __cnfn convert_ulong4_rte(char4)

convert_int_sat_rtp
int __ovld __cnfn convert_int_sat_rtp(char)

convert_ulong_rtp
ulong __ovld __cnfn convert_ulong_rtp(char)

convert_ushort2_rtp
ushort2 __ovld __cnfn convert_ushort2_rtp(char2)

atomic_fetch_min
int __ovld atomic_fetch_min(volatile atomic_int *object, int operand)

convert_uint16_sat
uint16 __ovld __cnfn convert_uint16_sat(char16)

convert_uchar8_sat
uchar8 __ovld __cnfn convert_uchar8_sat(char8)

convert_ushort2_rte
ushort2 __ovld __cnfn convert_ushort2_rte(char2)

vstore_half16_rtp
void __ovld vstore_half16_rtp(float16 data, size_t offset, half *p)

convert_char16
char16 __ovld __cnfn convert_char16(char16)

dot
float __ovld __cnfn dot(float p0, float p1)
Compute dot product.

__conv
#define __conv
Definition opencl-c.h:32

convert_float16_rte
float16 __ovld __cnfn convert_float16_rte(char16)

convert_char2_sat_rtz
char2 __ovld __cnfn convert_char2_sat_rtz(char2)

convert_uint
uint __ovld __cnfn convert_uint(char)

vstore_half2_rtn
void __ovld vstore_half2_rtn(float2 data, size_t offset, half *p)

convert_int8_rtn
int8 __ovld __cnfn convert_int8_rtn(char8)

convert_int4_rtn
int4 __ovld __cnfn convert_int4_rtn(char4)

get_image_channel_order
int __ovld __cnfn get_image_channel_order(read_only image1d_t image)
Return the image channel order.

convert_float8_rtp
float8 __ovld __cnfn convert_float8_rtp(char8)

convert_float4_rtn
float4 __ovld __cnfn convert_float4_rtn(char4)

convert_ushort4_rte
ushort4 __ovld __cnfn convert_ushort4_rte(char4)

vstore_half4_rtz
void __ovld vstore_half4_rtz(float4 data, size_t offset, half *p)

convert_uint3_sat_rtp
uint3 __ovld __cnfn convert_uint3_sat_rtp(char3)

convert_uint4
uint4 __ovld __cnfn convert_uint4(char4)

convert_ushort2_sat_rte
ushort2 __ovld __cnfn convert_ushort2_sat_rte(char2)

atomic_inc
int __ovld atomic_inc(volatile __global int *p)
Read the 32-bit value (referred to as old) stored at location pointed by p.

vstorea_half16_rte
void __ovld vstorea_half16_rte(float16 data, size_t offset, half *p)

convert_short_sat
short __ovld __cnfn convert_short_sat(char)

convert_uint2_sat_rte
uint2 __ovld __cnfn convert_uint2_sat_rte(char2)

fast_length
float __ovld __cnfn fast_length(float p)
Returns the length of vector p computed as: half_sqrt(p.x2 + p.y2 + ...)

convert_ushort_sat_rtn
ushort __ovld __cnfn convert_ushort_sat_rtn(char)

add_sat
char __ovld __cnfn add_sat(char x, char y)
Returns x + y and saturates the result.

convert_uint16_sat_rtz
uint16 __ovld __cnfn convert_uint16_sat_rtz(char16)

convert_ushort4_rtn
ushort4 __ovld __cnfn convert_ushort4_rtn(char4)

convert_uint4_sat_rtp
uint4 __ovld __cnfn convert_uint4_sat_rtp(char4)

ctz
char __ovld ctz(char x)
Returns the count of trailing 0-bits in x.

create_user_event
clk_event_t __ovld create_user_event(void)

convert_uchar4_rte
uchar4 __ovld __cnfn convert_uchar4_rte(char4)

convert_ushort2
ushort2 __ovld __cnfn convert_ushort2(char2)

convert_uint_sat_rtz
uint __ovld __cnfn convert_uint_sat_rtz(char)

convert_uchar2_sat_rtz
uchar2 __ovld __cnfn convert_uchar2_sat_rtz(char2)

convert_uint8_rtz
uint8 __ovld __cnfn convert_uint8_rtz(char8)

convert_ushort4
ushort4 __ovld __cnfn convert_ushort4(char4)

convert_char16_rtn
char16 __ovld __cnfn convert_char16_rtn(char16)

convert_ulong8_sat_rte
ulong8 __ovld __cnfn convert_ulong8_sat_rte(char8)

isordered
int __ovld __cnfn isordered(float x, float y)
Test if arguments are ordered.

vstore_half8_rtz
void __ovld vstore_half8_rtz(float8 data, size_t offset, half *p)

convert_uint3_sat_rte
uint3 __ovld __cnfn convert_uint3_sat_rte(char3)

convert_uint2
uint2 __ovld __cnfn convert_uint2(char2)

convert_uint8_sat_rtz
uint8 __ovld __cnfn convert_uint8_sat_rtz(char8)

convert_uint16_rte
uint16 __ovld __cnfn convert_uint16_rte(char16)

convert_short2_sat_rtn
short2 __ovld __cnfn convert_short2_sat_rtn(char2)

degrees
float __ovld __cnfn degrees(float radians)
Converts radians to degrees, i.e.

convert_char8_rte
char8 __ovld __cnfn convert_char8_rte(char8)

cospi
float __ovld __cnfn cospi(float x)
Compute cos (PI * x).

convert_float2_rtz
float2 __ovld __cnfn convert_float2_rtz(char2)

vload_half4
float4 __ovld vload_half4(size_t offset, const __constant half *p)

convert_char3_rte
char3 __ovld __cnfn convert_char3_rte(char3)

mad24
int __ovld __cnfn mad24(int x, int y, int z)
Multiply two 24-bit integer values x and y and add the 32-bit integer result to the 32-bit integer z.

convert_int_sat
int __ovld __cnfn convert_int_sat(char)

convert_char2_sat_rtn
char2 __ovld __cnfn convert_char2_sat_rtn(char2)

convert_ushort_rtp
ushort __ovld __cnfn convert_ushort_rtp(char)

vstorea_half3_rtn
void __ovld vstorea_half3_rtn(float3 data, size_t offset, half *p)

vstorea_half2_rtn
void __ovld vstorea_half2_rtn(float2 data, size_t offset, half *p)

work_group_all
int __ovld __conv work_group_all(int predicate)
Return the number of samples associated with image.

convert_ulong3_rte
ulong3 __ovld __cnfn convert_ulong3_rte(char3)

convert_ulong2_rtp
ulong2 __ovld __cnfn convert_ulong2_rtp(char2)

convert_ushort16_sat
ushort16 __ovld __cnfn convert_ushort16_sat(char16)

convert_short
short __ovld __cnfn convert_short(char)

convert_short8_rtn
short8 __ovld __cnfn convert_short8_rtn(char8)

convert_long3_rtn
long3 __ovld __cnfn convert_long3_rtn(char3)

vstorea_half3_rtp
void __ovld vstorea_half3_rtp(float3 data, size_t offset, half *p)

convert_char2_sat
char2 __ovld __cnfn convert_char2_sat(char2)

convert_ushort4_sat_rte
ushort4 __ovld __cnfn convert_ushort4_sat_rte(char4)

vstore_half4_rtn
void __ovld vstore_half4_rtn(float4 data, size_t offset, half *p)

convert_uchar3_sat_rtp
uchar3 __ovld __cnfn convert_uchar3_sat_rtp(char3)

work_group_reduce_add
int __ovld __conv work_group_reduce_add(int x)

smoothstep
float __ovld __cnfn smoothstep(float edge0, float edge1, float x)
Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 a...

convert_short4
short4 __ovld __cnfn convert_short4(char4)

convert_ulong3_rtz
ulong3 __ovld __cnfn convert_ulong3_rtz(char3)

convert_uchar16_rtn
uchar16 __ovld __cnfn convert_uchar16_rtn(char16)

get_local_size
size_t __ovld __cnfn get_local_size(uint dimindx)
Returns the number of local work-items specified in dimension identified by dimindx.

mix
float __ovld __cnfn mix(float x, float y, float a)
Returns the linear blend of x & y implemented as: x + (y - x) * a a must be a value in the range 0....

convert_ulong_sat_rtn
ulong __ovld __cnfn convert_ulong_sat_rtn(char)

convert_short16_rtz
short16 __ovld __cnfn convert_short16_rtz(char16)

convert_long2_rte
long2 __ovld __cnfn convert_long2_rte(char2)

write_imagei
void __ovld write_imagei(write_only image2d_t image, int2 coord, int4 color)

vloada_half3
float3 __ovld vloada_half3(size_t offset, const __constant half *p)

convert_uint4_rte
uint4 __ovld __cnfn convert_uint4_rte(char4)

convert_ushort8
ushort8 __ovld __cnfn convert_ushort8(char8)

convert_int8_rtz
int8 __ovld __cnfn convert_int8_rtz(char8)

__purefn
#define __purefn
Definition opencl-c.h:35

convert_ushort_sat_rtp
ushort __ovld __cnfn convert_ushort_sat_rtp(char)

convert_int3_sat
int3 __ovld __cnfn convert_int3_sat(char3)

get_fence
cl_mem_fence_flags __ovld get_fence(const void *ptr)

vstore_half_rte
void __ovld vstore_half_rte(float data, size_t offset, half *p)

atomic_fetch_xor
#define atomic_fetch_xor(object, operand)
Definition stdatomic.h:141

atomic_store
#define atomic_store(object, desired)
Definition stdatomic.h:117

atomic_compare_exchange_weak
#define atomic_compare_exchange_weak(object, expected, desired)
Definition stdatomic.h:129

atomic_compare_exchange_weak_explicit
#define atomic_compare_exchange_weak_explicit
Definition stdatomic.h:130

atomic_compare_exchange_strong
#define atomic_compare_exchange_strong(object, expected, desired)
Definition stdatomic.h:126

atomic_exchange
#define atomic_exchange(object, desired)
Definition stdatomic.h:123

atomic_fetch_or
#define atomic_fetch_or(object, operand)
Definition stdatomic.h:138

atomic_flag_clear
#define atomic_flag_clear(object)
Definition stdatomic.h:167

atomic_fetch_and_explicit
#define atomic_fetch_and_explicit
Definition stdatomic.h:145

atomic_fetch_sub
#define atomic_fetch_sub(object, operand)
Definition stdatomic.h:135

atomic_init
#define atomic_init
Definition stdatomic.h:43

atomic_fetch_sub_explicit
#define atomic_fetch_sub_explicit
Definition stdatomic.h:136

atomic_flag_test_and_set_explicit
#define atomic_flag_test_and_set_explicit(object, order)
Definition stdatomic.h:165

atomic_fetch_xor_explicit
#define atomic_fetch_xor_explicit
Definition stdatomic.h:142

atomic_store_explicit
#define atomic_store_explicit
Definition stdatomic.h:118

atomic_flag_test_and_set
#define atomic_flag_test_and_set(object)
Definition stdatomic.h:164

atomic_fetch_or_explicit
#define atomic_fetch_or_explicit
Definition stdatomic.h:139

atomic_load_explicit
#define atomic_load_explicit
Definition stdatomic.h:121

atomic_flag_clear_explicit
#define atomic_flag_clear_explicit(object, order)
Definition stdatomic.h:168

atomic_exchange_explicit
#define atomic_exchange_explicit
Definition stdatomic.h:124

atomic_load
#define atomic_load(object)
Definition stdatomic.h:120

atomic_fetch_and
#define atomic_fetch_and(object, operand)
Definition stdatomic.h:144

atomic_compare_exchange_strong_explicit
#define atomic_compare_exchange_strong_explicit
Definition stdatomic.h:127

atomic_fetch_add_explicit
#define atomic_fetch_add_explicit
Definition stdatomic.h:133

atomic_fetch_add
#define atomic_fetch_add(object, operand)
Definition stdatomic.h:132

atomic_flag
Definition stdatomic.h:149

ndrange_t
Definition opencl-c-base.h:424

sinh
#define sinh(__x)
Definition tgmath.h:373

asin
#define asin(__x)
Definition tgmath.h:112

sqrt
#define sqrt(__x)
Definition tgmath.h:520

acos
#define acos(__x)
Definition tgmath.h:83

fmin
#define fmin(__x, __y)
Definition tgmath.h:780

exp
#define exp(__x)
Definition tgmath.h:431

ilogb
#define ilogb(__x)
Definition tgmath.h:851

copysign
#define copysign(__x, __y)
Definition tgmath.h:618

erf
#define erf(__x)
Definition tgmath.h:636

atanh
#define atanh(__x)
Definition tgmath.h:228

remquo
#define remquo(__x, __y, __z)
Definition tgmath.h:1111

nextafter
#define nextafter(__x, __y)
Definition tgmath.h:1055

frexp
#define frexp(__x, __y)
Definition tgmath.h:816

asinh
#define asinh(__x)
Definition tgmath.h:199

erfc
#define erfc(__x)
Definition tgmath.h:653

atan2
#define atan2(__x, __y)
Definition tgmath.h:566

hypot
#define hypot(__x, __y)
Definition tgmath.h:833

exp2
#define exp2(__x)
Definition tgmath.h:670

sin
#define sin(__x)
Definition tgmath.h:286

cbrt
#define cbrt(__x)
Definition tgmath.h:584

log2
#define log2(__x)
Definition tgmath.h:970

cosh
#define cosh(__x)
Definition tgmath.h:344

trunc
#define trunc(__x)
Definition tgmath.h:1216

fmax
#define fmax(__x, __y)
Definition tgmath.h:762

ldexp
#define ldexp(__x, __y)
Definition tgmath.h:868

acosh
#define acosh(__x)
Definition tgmath.h:170

tgamma
#define tgamma(__x)
Definition tgmath.h:1199

round
#define round(__x)
Definition tgmath.h:1148

fmod
#define fmod(__x, __y)
Definition tgmath.h:798

tan
#define tan(__x)
Definition tgmath.h:315

cos
#define cos(__x)
Definition tgmath.h:257

log10
#define log10(__x)
Definition tgmath.h:936

fabs
#define fabs(__x)
Definition tgmath.h:549

pow
#define pow(__x, __y)
Definition tgmath.h:490

log1p
#define log1p(__x)
Definition tgmath.h:953

rint
#define rint(__x)
Definition tgmath.h:1131

expm1
#define expm1(__x)
Definition tgmath.h:687

remainder
#define remainder(__x, __y)
Definition tgmath.h:1090

fdim
#define fdim(__x, __y)
Definition tgmath.h:704

lgamma
#define lgamma(__x)
Definition tgmath.h:885

tanh
#define tanh(__x)
Definition tgmath.h:402

atan
#define atan(__x)
Definition tgmath.h:141

floor
#define floor(__x)
Definition tgmath.h:722

ceil
#define ceil(__x)
Definition tgmath.h:601

log
#define log(__x)
Definition tgmath.h:460

logb
#define logb(__x)
Definition tgmath.h:987

fma
#define fma(__x, __y, __z)
Definition tgmath.h:742