#line 1 "kernel.cl"
#line 1 "kernel.cl"
#line 1 "<built-in>"
#line 1 "<built-in>"
#line 132 "<built-in>"
#line 1 "<command line>"
#line 1 "<built-in>"
#line 1 "kernel.cl"
#line 94 "kernel.cl"
#line 1 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"
#line 10 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned int size_t;



#line 1 "C:\\prog\\GPUVerifyBenchmarking\\include_cl/opencl_vectors.h"

typedef char char2 __attribute__((ext_vector_type(2)));
typedef char char3 __attribute__((ext_vector_type(3)));
typedef char char4 __attribute__((ext_vector_type(4)));
typedef char char8 __attribute__((ext_vector_type(8)));
typedef char char16 __attribute__((ext_vector_type(16)));
typedef unsigned char uchar2 __attribute__((ext_vector_type(2)));
typedef unsigned char uchar3 __attribute__((ext_vector_type(3)));
typedef unsigned char uchar4 __attribute__((ext_vector_type(4)));
typedef unsigned char uchar8 __attribute__((ext_vector_type(8)));
typedef unsigned char uchar16 __attribute__((ext_vector_type(16)));

typedef short short2 __attribute__((ext_vector_type(2)));
typedef short short3 __attribute__((ext_vector_type(3)));
typedef short short4 __attribute__((ext_vector_type(4)));
typedef short short8 __attribute__((ext_vector_type(8)));
typedef short short16 __attribute__((ext_vector_type(16)));
typedef unsigned short ushort2 __attribute__((ext_vector_type(2)));
typedef unsigned short ushort3 __attribute__((ext_vector_type(3)));
typedef unsigned short ushort4 __attribute__((ext_vector_type(4)));
typedef unsigned short ushort8 __attribute__((ext_vector_type(8)));
typedef unsigned short ushort16 __attribute__((ext_vector_type(16)));

typedef int int2 __attribute__((ext_vector_type(2)));
typedef int int3 __attribute__((ext_vector_type(3)));
typedef int int4 __attribute__((ext_vector_type(4)));
typedef int int8 __attribute__((ext_vector_type(8)));
typedef int int16 __attribute__((ext_vector_type(16)));
typedef unsigned int uint2 __attribute__((ext_vector_type(2)));
typedef unsigned int uint3 __attribute__((ext_vector_type(3)));
typedef unsigned int uint4 __attribute__((ext_vector_type(4)));
typedef unsigned int uint8 __attribute__((ext_vector_type(8)));
typedef unsigned int uint16 __attribute__((ext_vector_type(16)));

typedef long long2 __attribute__((ext_vector_type(2)));
typedef long long3 __attribute__((ext_vector_type(3)));
typedef long long4 __attribute__((ext_vector_type(4)));
typedef long long8 __attribute__((ext_vector_type(8)));
typedef long long16 __attribute__((ext_vector_type(16)));
typedef unsigned long ulong2 __attribute__((ext_vector_type(2)));
typedef unsigned long ulong3 __attribute__((ext_vector_type(3)));
typedef unsigned long ulong4 __attribute__((ext_vector_type(4)));
typedef unsigned long ulong8 __attribute__((ext_vector_type(8)));
typedef unsigned long ulong16 __attribute__((ext_vector_type(16)));

typedef float float2 __attribute__((ext_vector_type(2)));
typedef float float3 __attribute__((ext_vector_type(3)));
typedef float float4 __attribute__((ext_vector_type(4)));
typedef float float8 __attribute__((ext_vector_type(8)));
typedef float float16 __attribute__((ext_vector_type(16)));



#pragma OPENCL EXTENSION cl_khr_fp64: enable

typedef double double2 __attribute__((ext_vector_type(2)));
typedef double double3 __attribute__((ext_vector_type(3)));
typedef double double4 __attribute__((ext_vector_type(4)));
typedef double double8 __attribute__((ext_vector_type(8)));
typedef double double16 __attribute__((ext_vector_type(16)));
#line 16 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"




typedef struct image2d_s
{
} image2d_t;

typedef struct image3d_s
{
} image3d_t;
#line 38 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"
typedef unsigned int sampler_t;

float4 read_imagef(image2d_t image, sampler_t sampler, uint2 coord);
int4 read_imagei(image2d_t image, sampler_t sampler, uint2 coord);
uint4 read_imageui(image2d_t image, sampler_t sampler, uint2 coord);

void write_imagef(image2d_t image, uint2 coords, float4 color);
void write_imagei(image2d_t image, uint2 coords, int4 color);
void write_imageui(image2d_t image, uint2 coords, uint4 color);

int get_image_height (image2d_t image);
int get_image_width (image2d_t image);


#line 1 "C:\\prog\\GPUVerifyBenchmarking\\include_cl/annotations.h"
#line 11 "C:\\prog\\GPUVerifyBenchmarking\\include_cl/annotations.h"
                     void __invariant(bool expr);


                     void __requires(bool expr);


                     void __ensures(bool expr);


                     int __return_val_int();
                     bool __return_val_bool();

                     int4 __return_val_int4();



                     int __old_int();
                     bool __old_bool();


                     void __assume(bool expr);


                     void __assert(bool expr);


                     bool __enabled();


                     bool __implies(bool expr1, bool expr2);


                     bool __no_read(const char* array_name);


                     bool __read(const char* array_name);


                     bool __no_write(const char* array_name);


                     bool __write(const char* array_name);


                     int __read_offset(const char* array_name);


                     int __write_offset(const char* array_name);


                     bool __read_implies(const char* array_name, bool expr);


                     bool __write_implies(const char* array_name, bool expr);



bool __points_to_global(const __global void* array, const char* array_name);
bool __points_to_local(const __local void* array, const char* array_name);
bool __points_to_private(const __private void* array, const char* array_name);





                     bool __uniform_int(int expr);
                     bool __uniform_bool(bool expr);


                     bool __distinct_int(int expr);
                     bool __distinct_bool(bool expr);


                     bool __all(bool expr);


                     bool __at_most_one(bool expr);
#line 51 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"






int mul24(int, int);

int get_group_id(int);
int get_local_id(int);
int get_local_size(int);
int get_global_id(int);
int get_num_groups(int);
int get_global_size(int);

float3 vload3(int, const __global float *);


float4 cbrt_4(float4);
int4 clamp_4(int4, int4, int4);
float4 clamp_4_f(float4, float4, float4);
float4 convert_float4_i(int4);
float4 convert_float4_ui(uint4);
float4 convert_float4_rtp_i(int4);
float4 convert_float4_rtp_ui(uint4);
float3 cross_3(float3, float3);
float4 cross_4(float4, float4);
float dot_2(float2, float2);
float dot_3(float3, float3);
float dot_4(float4, float4);
float fast_length_2(float2);
float fast_length_3(float3);
float fast_length_4(float4);
float3 fast_normalize_3(float3);
float4 fast_normalize_4(float4);
float4 half_exp_4(float4);
float4 half_powr_4(float4, float4);
float length_4(float4);
float2 max_2(float2, float2);
float3 max_3(float3, float3);
float4 max_4(float4, float4);
float2 min_2(float2, float2);
float3 min_3(float3, float3);
float4 min_4(float4, float4);



#line 1 "C:\\prog\\GPUVerifyBenchmarking\\include_cl/opencl_common_functions.h"

float __attribute__((overloadable)) clamp(float x, float y, float z);
float2 __attribute__((overloadable)) clamp(float2 x, float2 y, float2 z);
float3 __attribute__((overloadable)) clamp(float3 x, float3 y, float3 z);
float4 __attribute__((overloadable)) clamp(float4 x, float4 y, float4 z);
float8 __attribute__((overloadable)) clamp(float8 x, float8 y, float8 z);
float16 __attribute__((overloadable)) clamp(float16 x, float16 y, float16 z);
double __attribute__((overloadable)) clamp(double x, double y, double z);
double2 __attribute__((overloadable)) clamp(double2 x, double2 y, double2 z);
double3 __attribute__((overloadable)) clamp(double3 x, double3 y, double3 z);
double4 __attribute__((overloadable)) clamp(double4 x, double4 y, double4 z);
double8 __attribute__((overloadable)) clamp(double8 x, double8 y, double8 z);
double16 __attribute__((overloadable)) clamp(double16 x, double16 y, double16 z);

float __attribute__((overloadable)) clamp(float x, float y, float z);
float2 __attribute__((overloadable)) clamp(float2 x, float y, float z);
float3 __attribute__((overloadable)) clamp(float3 x, float y, float z);
float4 __attribute__((overloadable)) clamp(float4 x, float y, float z);
float8 __attribute__((overloadable)) clamp(float8 x, float y, float z);
float16 __attribute__((overloadable)) clamp(float16 x, float y, float z);

float __attribute__((overloadable)) clamp(float x, double y, double z);
float2 __attribute__((overloadable)) clamp(float2 x, double y, double z);
float3 __attribute__((overloadable)) clamp(float3 x, double y, double z);
float4 __attribute__((overloadable)) clamp(float4 x, double y, double z);
float8 __attribute__((overloadable)) clamp(float8 x, double y, double z);
float16 __attribute__((overloadable)) clamp(float16 x, double y, double z);

float __attribute__((overloadable)) degrees(float x);
float2 __attribute__((overloadable)) degrees(float2 x);
float3 __attribute__((overloadable)) degrees(float3 x);
float4 __attribute__((overloadable)) degrees(float4 x);
float8 __attribute__((overloadable)) degrees(float8 x);
float16 __attribute__((overloadable)) degrees(float16 x);
double __attribute__((overloadable)) degrees(double x);
double2 __attribute__((overloadable)) degrees(double2 x);
double3 __attribute__((overloadable)) degrees(double3 x);
double4 __attribute__((overloadable)) degrees(double4 x);
double8 __attribute__((overloadable)) degrees(double8 x);
double16 __attribute__((overloadable)) degrees(double16 x);

float __attribute__((overloadable)) max(float x, float y);
float2 __attribute__((overloadable)) max(float2 x, float2 y);
float3 __attribute__((overloadable)) max(float3 x, float3 y);
float4 __attribute__((overloadable)) max(float4 x, float4 y);
float8 __attribute__((overloadable)) max(float8 x, float8 y);
float16 __attribute__((overloadable)) max(float16 x, float16 y);
double __attribute__((overloadable)) max(double x, double y);
double2 __attribute__((overloadable)) max(double2 x, double2 y);
double3 __attribute__((overloadable)) max(double3 x, double3 y);
double4 __attribute__((overloadable)) max(double4 x, double4 y);
double8 __attribute__((overloadable)) max(double8 x, double8 y);
double16 __attribute__((overloadable)) max(double16 x, double16 y);

float __attribute__((overloadable)) max(float x, float y);
float2 __attribute__((overloadable)) max(float2 x, float y);
float3 __attribute__((overloadable)) max(float3 x, float y);
float4 __attribute__((overloadable)) max(float4 x, float y);
float8 __attribute__((overloadable)) max(float8 x, float y);
float16 __attribute__((overloadable)) max(float16 x, float y);

float __attribute__((overloadable)) max(float x, double y);
float2 __attribute__((overloadable)) max(float2 x, double y);
float3 __attribute__((overloadable)) max(float3 x, double y);
float4 __attribute__((overloadable)) max(float4 x, double y);
float8 __attribute__((overloadable)) max(float8 x, double y);
float16 __attribute__((overloadable)) max(float16 x, double y);

float __attribute__((overloadable)) min(float x, float y);
float2 __attribute__((overloadable)) min(float2 x, float2 y);
float3 __attribute__((overloadable)) min(float3 x, float3 y);
float4 __attribute__((overloadable)) min(float4 x, float4 y);
float8 __attribute__((overloadable)) min(float8 x, float8 y);
float16 __attribute__((overloadable)) min(float16 x, float16 y);
double __attribute__((overloadable)) min(double x, double y);
double2 __attribute__((overloadable)) min(double2 x, double2 y);
double3 __attribute__((overloadable)) min(double3 x, double3 y);
double4 __attribute__((overloadable)) min(double4 x, double4 y);
double8 __attribute__((overloadable)) min(double8 x, double8 y);
double16 __attribute__((overloadable)) min(double16 x, double16 y);

float __attribute__((overloadable)) min(float x, float y);
float2 __attribute__((overloadable)) min(float2 x, float y);
float3 __attribute__((overloadable)) min(float3 x, float y);
float4 __attribute__((overloadable)) min(float4 x, float y);
float8 __attribute__((overloadable)) min(float8 x, float y);
float16 __attribute__((overloadable)) min(float16 x, float y);

float __attribute__((overloadable)) min(float x, double y);
float2 __attribute__((overloadable)) min(float2 x, double y);
float3 __attribute__((overloadable)) min(float3 x, double y);
float4 __attribute__((overloadable)) min(float4 x, double y);
float8 __attribute__((overloadable)) min(float8 x, double y);
float16 __attribute__((overloadable)) min(float16 x, double y);

float __attribute__((overloadable)) mix(float x, float y, float z);
float2 __attribute__((overloadable)) mix(float2 x, float2 y, float2 z);
float3 __attribute__((overloadable)) mix(float3 x, float3 y, float3 z);
float4 __attribute__((overloadable)) mix(float4 x, float4 y, float4 z);
float8 __attribute__((overloadable)) mix(float8 x, float8 y, float8 z);
float16 __attribute__((overloadable)) mix(float16 x, float16 y, float16 z);
double __attribute__((overloadable)) mix(double x, double y, double z);
double2 __attribute__((overloadable)) mix(double2 x, double2 y, double2 z);
double3 __attribute__((overloadable)) mix(double3 x, double3 y, double3 z);
double4 __attribute__((overloadable)) mix(double4 x, double4 y, double4 z);
double8 __attribute__((overloadable)) mix(double8 x, double8 y, double8 z);
double16 __attribute__((overloadable)) mix(double16 x, double16 y, double16 z);

float __attribute__((overloadable)) mix(float x, float y, float z);
float2 __attribute__((overloadable)) mix(float2 x, float2 y, float z);
float3 __attribute__((overloadable)) mix(float3 x, float3 y, float z);
float4 __attribute__((overloadable)) mix(float4 x, float4 y, float z);
float8 __attribute__((overloadable)) mix(float8 x, float8 y, float z);
float16 __attribute__((overloadable)) mix(float16 x, float16 y, float z);

float __attribute__((overloadable)) mix(float x, float y, double z);
float2 __attribute__((overloadable)) mix(float2 x, float2 y, double z);
float3 __attribute__((overloadable)) mix(float3 x, float3 y, double z);
float4 __attribute__((overloadable)) mix(float4 x, float4 y, double z);
float8 __attribute__((overloadable)) mix(float8 x, float8 y, double z);
float16 __attribute__((overloadable)) mix(float16 x, float16 y, double z);

float __attribute__((overloadable)) radians(float x);
float2 __attribute__((overloadable)) radians(float2 x);
float3 __attribute__((overloadable)) radians(float3 x);
float4 __attribute__((overloadable)) radians(float4 x);
float8 __attribute__((overloadable)) radians(float8 x);
float16 __attribute__((overloadable)) radians(float16 x);
double __attribute__((overloadable)) radians(double x);
double2 __attribute__((overloadable)) radians(double2 x);
double3 __attribute__((overloadable)) radians(double3 x);
double4 __attribute__((overloadable)) radians(double4 x);
double8 __attribute__((overloadable)) radians(double8 x);
double16 __attribute__((overloadable)) radians(double16 x);

float __attribute__((overloadable)) step(float x, float y);
float2 __attribute__((overloadable)) step(float2 x, float2 y);
float3 __attribute__((overloadable)) step(float3 x, float3 y);
float4 __attribute__((overloadable)) step(float4 x, float4 y);
float8 __attribute__((overloadable)) step(float8 x, float8 y);
float16 __attribute__((overloadable)) step(float16 x, float16 y);
double __attribute__((overloadable)) step(double x, double y);
double2 __attribute__((overloadable)) step(double2 x, double2 y);
double3 __attribute__((overloadable)) step(double3 x, double3 y);
double4 __attribute__((overloadable)) step(double4 x, double4 y);
double8 __attribute__((overloadable)) step(double8 x, double8 y);
double16 __attribute__((overloadable)) step(double16 x, double16 y);

float __attribute__((overloadable)) step(float x, float y);
float2 __attribute__((overloadable)) step(float x, float2 y);
float3 __attribute__((overloadable)) step(float x, float3 y);
float4 __attribute__((overloadable)) step(float x, float4 y);
float8 __attribute__((overloadable)) step(float x, float8 y);
float16 __attribute__((overloadable)) step(float x, float16 y);

float __attribute__((overloadable)) step(double x, float y);
float2 __attribute__((overloadable)) step(double x, float2 y);
float3 __attribute__((overloadable)) step(double x, float3 y);
float4 __attribute__((overloadable)) step(double x, float4 y);
float8 __attribute__((overloadable)) step(double x, float8 y);
float16 __attribute__((overloadable)) step(double x, float16 y);

float __attribute__((overloadable)) smoothstep(float x, float y);
float2 __attribute__((overloadable)) smoothstep(float2 x, float2 y);
float3 __attribute__((overloadable)) smoothstep(float3 x, float3 y);
float4 __attribute__((overloadable)) smoothstep(float4 x, float4 y);
float8 __attribute__((overloadable)) smoothstep(float8 x, float8 y);
float16 __attribute__((overloadable)) smoothstep(float16 x, float16 y);
double __attribute__((overloadable)) smoothstep(double x, double y);
double2 __attribute__((overloadable)) smoothstep(double2 x, double2 y);
double3 __attribute__((overloadable)) smoothstep(double3 x, double3 y);
double4 __attribute__((overloadable)) smoothstep(double4 x, double4 y);
double8 __attribute__((overloadable)) smoothstep(double8 x, double8 y);
double16 __attribute__((overloadable)) smoothstep(double16 x, double16 y);

float __attribute__((overloadable)) smoothstep(float x, float y);
float2 __attribute__((overloadable)) smoothstep(float x, float2 y);
float3 __attribute__((overloadable)) smoothstep(float x, float3 y);
float4 __attribute__((overloadable)) smoothstep(float x, float4 y);
float8 __attribute__((overloadable)) smoothstep(float x, float8 y);
float16 __attribute__((overloadable)) smoothstep(float x, float16 y);

float __attribute__((overloadable)) smoothstep(double x, float y);
float2 __attribute__((overloadable)) smoothstep(double x, float2 y);
float3 __attribute__((overloadable)) smoothstep(double x, float3 y);
float4 __attribute__((overloadable)) smoothstep(double x, float4 y);
float8 __attribute__((overloadable)) smoothstep(double x, float8 y);
float16 __attribute__((overloadable)) smoothstep(double x, float16 y);

float __attribute__((overloadable)) sign(float x);
float2 __attribute__((overloadable)) sign(float2 x);
float3 __attribute__((overloadable)) sign(float3 x);
float4 __attribute__((overloadable)) sign(float4 x);
float8 __attribute__((overloadable)) sign(float8 x);
float16 __attribute__((overloadable)) sign(float16 x);
double __attribute__((overloadable)) sign(double x);
double2 __attribute__((overloadable)) sign(double2 x);
double3 __attribute__((overloadable)) sign(double3 x);
double4 __attribute__((overloadable)) sign(double4 x);
double8 __attribute__((overloadable)) sign(double8 x);
double16 __attribute__((overloadable)) sign(double16 x);
#line 97 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"

#line 1 "C:\\prog\\GPUVerifyBenchmarking\\include_cl/opencl_geometric_functions.h"

float4 __attribute__((overloadable)) cross(float4 x, float4 y);
float3 __attribute__((overloadable)) cross(float3 x, float3 y);
double4 __attribute__((overloadable)) cross(double4 x, double4 y);
double3 __attribute__((overloadable)) cross(double3 x, double3 y);

float __attribute__((overloadable)) dot(float x, float y);
float __attribute__((overloadable)) dot(float2 x, float2 y);
float __attribute__((overloadable)) dot(float3 x, float3 y);
float __attribute__((overloadable)) dot(float4 x, float4 y);
float __attribute__((overloadable)) dot(float8 x, float8 y);
float __attribute__((overloadable)) dot(float16 x, float16 y);

double __attribute__((overloadable)) dot(double x, double y);
double __attribute__((overloadable)) dot(double2 x, double2 y);
double __attribute__((overloadable)) dot(double3 x, double3 y);
double __attribute__((overloadable)) dot(double4 x, double4 y);
double __attribute__((overloadable)) dot(double8 x, double8 y);
double __attribute__((overloadable)) dot(double16 x, double16 y);

float __attribute__((overloadable)) distance(float x, float y);
float __attribute__((overloadable)) distance(float2 x, float2 y);
float __attribute__((overloadable)) distance(float3 x, float3 y);
float __attribute__((overloadable)) distance(float4 x, float4 y);
float __attribute__((overloadable)) distance(float8 x, float8 y);
float __attribute__((overloadable)) distance(float16 x, float16 y);

double __attribute__((overloadable)) distance(double x, double y);
double __attribute__((overloadable)) distance(double2 x, double2 y);
double __attribute__((overloadable)) distance(double3 x, double3 y);
double __attribute__((overloadable)) distance(double4 x, double4 y);
double __attribute__((overloadable)) distance(double8 x, double8 y);
double __attribute__((overloadable)) distance(double16 x, double16 y);

float __attribute__((overloadable)) length(float x);
float __attribute__((overloadable)) length(float2 x);
float __attribute__((overloadable)) length(float3 x);
float __attribute__((overloadable)) length(float4 x);
float __attribute__((overloadable)) length(float8 x);
float __attribute__((overloadable)) length(float16 x);

double __attribute__((overloadable)) length(double x);
double __attribute__((overloadable)) length(double2 x);
double __attribute__((overloadable)) length(double3 x);
double __attribute__((overloadable)) length(double4 x);
double __attribute__((overloadable)) length(double8 x);
double __attribute__((overloadable)) length(double16 x);

float __attribute__((overloadable)) normalize(float x);
float2 __attribute__((overloadable)) normalize(float2 x);
float3 __attribute__((overloadable)) normalize(float3 x);
float4 __attribute__((overloadable)) normalize(float4 x);
float8 __attribute__((overloadable)) normalize(float8 x);
float16 __attribute__((overloadable)) normalize(float16 x);

double __attribute__((overloadable)) normalize(double x);
double2 __attribute__((overloadable)) normalize(double2 x);
double3 __attribute__((overloadable)) normalize(double3 x);
double4 __attribute__((overloadable)) normalize(double4 x);
double8 __attribute__((overloadable)) normalize(double8 x);
double16 __attribute__((overloadable)) normalize(double16 x);

float __attribute__((overloadable)) fast_distance(float x, float y);
float __attribute__((overloadable)) fast_distance(float2 x, float2 y);
float __attribute__((overloadable)) fast_distance(float3 x, float3 y);
float __attribute__((overloadable)) fast_distance(float4 x, float4 y);
float __attribute__((overloadable)) fast_distance(float8 x, float8 y);
float __attribute__((overloadable)) fast_distance(float16 x, float16 y);

float __attribute__((overloadable)) fast_length(float x);
float __attribute__((overloadable)) fast_length(float2 x);
float __attribute__((overloadable)) fast_length(float3 x);
float __attribute__((overloadable)) fast_length(float4 x);
float __attribute__((overloadable)) fast_length(float8 x);
float __attribute__((overloadable)) fast_length(float16 x);

float __attribute__((overloadable)) fast_normalize(float x);
float2 __attribute__((overloadable)) fast_normalize(float2 x);
float3 __attribute__((overloadable)) fast_normalize(float3 x);
float4 __attribute__((overloadable)) fast_normalize(float4 x);
float8 __attribute__((overloadable)) fast_normalize(float8 x);
float16 __attribute__((overloadable)) fast_normalize(float16 x);
#line 98 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"

#line 1 "C:\\prog\\GPUVerifyBenchmarking\\include_cl/opencl_math_functions.h"

float __attribute__((overloadable)) acos(float x);
float2 __attribute__((overloadable)) acos(float2 x);
float3 __attribute__((overloadable)) acos(float3 x);
float4 __attribute__((overloadable)) acos(float4 x);
float8 __attribute__((overloadable)) acos(float8 x);
float16 __attribute__((overloadable)) acos(float16 x);
double __attribute__((overloadable)) acos(double x);
double2 __attribute__((overloadable)) acos(double2 x);
double3 __attribute__((overloadable)) acos(double3 x);
double4 __attribute__((overloadable)) acos(double4 x);
double8 __attribute__((overloadable)) acos(double8 x);
double16 __attribute__((overloadable)) acos(double16 x);
float __attribute__((overloadable)) acosh(float x);
float2 __attribute__((overloadable)) acosh(float2 x);
float3 __attribute__((overloadable)) acosh(float3 x);
float4 __attribute__((overloadable)) acosh(float4 x);
float8 __attribute__((overloadable)) acosh(float8 x);
float16 __attribute__((overloadable)) acosh(float16 x);
double __attribute__((overloadable)) acosh(double x);
double2 __attribute__((overloadable)) acosh(double2 x);
double3 __attribute__((overloadable)) acosh(double3 x);
double4 __attribute__((overloadable)) acosh(double4 x);
double8 __attribute__((overloadable)) acosh(double8 x);
double16 __attribute__((overloadable)) acosh(double16 x);
float __attribute__((overloadable)) acospi(float x);
float2 __attribute__((overloadable)) acospi(float2 x);
float3 __attribute__((overloadable)) acospi(float3 x);
float4 __attribute__((overloadable)) acospi(float4 x);
float8 __attribute__((overloadable)) acospi(float8 x);
float16 __attribute__((overloadable)) acospi(float16 x);
double __attribute__((overloadable)) acospi(double x);
double2 __attribute__((overloadable)) acospi(double2 x);
double3 __attribute__((overloadable)) acospi(double3 x);
double4 __attribute__((overloadable)) acospi(double4 x);
double8 __attribute__((overloadable)) acospi(double8 x);
double16 __attribute__((overloadable)) acospi(double16 x);
float __attribute__((overloadable)) asin(float x);
float2 __attribute__((overloadable)) asin(float2 x);
float3 __attribute__((overloadable)) asin(float3 x);
float4 __attribute__((overloadable)) asin(float4 x);
float8 __attribute__((overloadable)) asin(float8 x);
float16 __attribute__((overloadable)) asin(float16 x);
double __attribute__((overloadable)) asin(double x);
double2 __attribute__((overloadable)) asin(double2 x);
double3 __attribute__((overloadable)) asin(double3 x);
double4 __attribute__((overloadable)) asin(double4 x);
double8 __attribute__((overloadable)) asin(double8 x);
double16 __attribute__((overloadable)) asin(double16 x);
float __attribute__((overloadable)) asinh(float x);
float2 __attribute__((overloadable)) asinh(float2 x);
float3 __attribute__((overloadable)) asinh(float3 x);
float4 __attribute__((overloadable)) asinh(float4 x);
float8 __attribute__((overloadable)) asinh(float8 x);
float16 __attribute__((overloadable)) asinh(float16 x);
double __attribute__((overloadable)) asinh(double x);
double2 __attribute__((overloadable)) asinh(double2 x);
double3 __attribute__((overloadable)) asinh(double3 x);
double4 __attribute__((overloadable)) asinh(double4 x);
double8 __attribute__((overloadable)) asinh(double8 x);
double16 __attribute__((overloadable)) asinh(double16 x);
float __attribute__((overloadable)) asinpi(float x);
float2 __attribute__((overloadable)) asinpi(float2 x);
float3 __attribute__((overloadable)) asinpi(float3 x);
float4 __attribute__((overloadable)) asinpi(float4 x);
float8 __attribute__((overloadable)) asinpi(float8 x);
float16 __attribute__((overloadable)) asinpi(float16 x);
double __attribute__((overloadable)) asinpi(double x);
double2 __attribute__((overloadable)) asinpi(double2 x);
double3 __attribute__((overloadable)) asinpi(double3 x);
double4 __attribute__((overloadable)) asinpi(double4 x);
double8 __attribute__((overloadable)) asinpi(double8 x);
double16 __attribute__((overloadable)) asinpi(double16 x);
float __attribute__((overloadable)) atan(float x);
float2 __attribute__((overloadable)) atan(float2 x);
float3 __attribute__((overloadable)) atan(float3 x);
float4 __attribute__((overloadable)) atan(float4 x);
float8 __attribute__((overloadable)) atan(float8 x);
float16 __attribute__((overloadable)) atan(float16 x);
double __attribute__((overloadable)) atan(double x);
double2 __attribute__((overloadable)) atan(double2 x);
double3 __attribute__((overloadable)) atan(double3 x);
double4 __attribute__((overloadable)) atan(double4 x);
double8 __attribute__((overloadable)) atan(double8 x);
double16 __attribute__((overloadable)) atan(double16 x);
float __attribute__((overloadable)) atan2(float x, float y);
float2 __attribute__((overloadable)) atan2(float2 x, float2 y);
float3 __attribute__((overloadable)) atan2(float3 x, float3 y);
float4 __attribute__((overloadable)) atan2(float4 x, float4 y);
float8 __attribute__((overloadable)) atan2(float8 x, float8 y);
float16 __attribute__((overloadable)) atan2(float16 x, float16 y);
double __attribute__((overloadable)) atan2(double x, double y);
double2 __attribute__((overloadable)) atan2(double2 x, double2 y);
double3 __attribute__((overloadable)) atan2(double3 x, double3 y);
double4 __attribute__((overloadable)) atan2(double4 x, double4 y);
double8 __attribute__((overloadable)) atan2(double8 x, double8 y);
double16 __attribute__((overloadable)) atan2(double16 x, double16 y);
float __attribute__((overloadable)) atanh(float x);
float2 __attribute__((overloadable)) atanh(float2 x);
float3 __attribute__((overloadable)) atanh(float3 x);
float4 __attribute__((overloadable)) atanh(float4 x);
float8 __attribute__((overloadable)) atanh(float8 x);
float16 __attribute__((overloadable)) atanh(float16 x);
double __attribute__((overloadable)) atanh(double x);
double2 __attribute__((overloadable)) atanh(double2 x);
double3 __attribute__((overloadable)) atanh(double3 x);
double4 __attribute__((overloadable)) atanh(double4 x);
double8 __attribute__((overloadable)) atanh(double8 x);
double16 __attribute__((overloadable)) atanh(double16 x);
float __attribute__((overloadable)) atanpi(float x);
float2 __attribute__((overloadable)) atanpi(float2 x);
float3 __attribute__((overloadable)) atanpi(float3 x);
float4 __attribute__((overloadable)) atanpi(float4 x);
float8 __attribute__((overloadable)) atanpi(float8 x);
float16 __attribute__((overloadable)) atanpi(float16 x);
double __attribute__((overloadable)) atanpi(double x);
double2 __attribute__((overloadable)) atanpi(double2 x);
double3 __attribute__((overloadable)) atanpi(double3 x);
double4 __attribute__((overloadable)) atanpi(double4 x);
double8 __attribute__((overloadable)) atanpi(double8 x);
double16 __attribute__((overloadable)) atanpi(double16 x);
float __attribute__((overloadable)) cbrt(float x);
float2 __attribute__((overloadable)) cbrt(float2 x);
float3 __attribute__((overloadable)) cbrt(float3 x);
float4 __attribute__((overloadable)) cbrt(float4 x);
float8 __attribute__((overloadable)) cbrt(float8 x);
float16 __attribute__((overloadable)) cbrt(float16 x);
double __attribute__((overloadable)) cbrt(double x);
double2 __attribute__((overloadable)) cbrt(double2 x);
double3 __attribute__((overloadable)) cbrt(double3 x);
double4 __attribute__((overloadable)) cbrt(double4 x);
double8 __attribute__((overloadable)) cbrt(double8 x);
double16 __attribute__((overloadable)) cbrt(double16 x);
float __attribute__((overloadable)) ceil(float x);
float2 __attribute__((overloadable)) ceil(float2 x);
float3 __attribute__((overloadable)) ceil(float3 x);
float4 __attribute__((overloadable)) ceil(float4 x);
float8 __attribute__((overloadable)) ceil(float8 x);
float16 __attribute__((overloadable)) ceil(float16 x);
double __attribute__((overloadable)) ceil(double x);
double2 __attribute__((overloadable)) ceil(double2 x);
double3 __attribute__((overloadable)) ceil(double3 x);
double4 __attribute__((overloadable)) ceil(double4 x);
double8 __attribute__((overloadable)) ceil(double8 x);
double16 __attribute__((overloadable)) ceil(double16 x);
float __attribute__((overloadable)) copysign(float x, float y);
float2 __attribute__((overloadable)) copysign(float2 x, float2 y);
float3 __attribute__((overloadable)) copysign(float3 x, float3 y);
float4 __attribute__((overloadable)) copysign(float4 x, float4 y);
float8 __attribute__((overloadable)) copysign(float8 x, float8 y);
float16 __attribute__((overloadable)) copysign(float16 x, float16 y);
double __attribute__((overloadable)) copysign(double x, double y);
double2 __attribute__((overloadable)) copysign(double2 x, double2 y);
double3 __attribute__((overloadable)) copysign(double3 x, double3 y);
double4 __attribute__((overloadable)) copysign(double4 x, double4 y);
double8 __attribute__((overloadable)) copysign(double8 x, double8 y);
double16 __attribute__((overloadable)) copysign(double16 x, double16 y);
float __attribute__((overloadable)) cos(float x);
float2 __attribute__((overloadable)) cos(float2 x);
float3 __attribute__((overloadable)) cos(float3 x);
float4 __attribute__((overloadable)) cos(float4 x);
float8 __attribute__((overloadable)) cos(float8 x);
float16 __attribute__((overloadable)) cos(float16 x);
double __attribute__((overloadable)) cos(double x);
double2 __attribute__((overloadable)) cos(double2 x);
double3 __attribute__((overloadable)) cos(double3 x);
double4 __attribute__((overloadable)) cos(double4 x);
double8 __attribute__((overloadable)) cos(double8 x);
double16 __attribute__((overloadable)) cos(double16 x);
float __attribute__((overloadable)) cosh(float x);
float2 __attribute__((overloadable)) cosh(float2 x);
float3 __attribute__((overloadable)) cosh(float3 x);
float4 __attribute__((overloadable)) cosh(float4 x);
float8 __attribute__((overloadable)) cosh(float8 x);
float16 __attribute__((overloadable)) cosh(float16 x);
double __attribute__((overloadable)) cosh(double x);
double2 __attribute__((overloadable)) cosh(double2 x);
double3 __attribute__((overloadable)) cosh(double3 x);
double4 __attribute__((overloadable)) cosh(double4 x);
double8 __attribute__((overloadable)) cosh(double8 x);
double16 __attribute__((overloadable)) cosh(double16 x);
float __attribute__((overloadable)) cospi(float x);
float2 __attribute__((overloadable)) cospi(float2 x);
float3 __attribute__((overloadable)) cospi(float3 x);
float4 __attribute__((overloadable)) cospi(float4 x);
float8 __attribute__((overloadable)) cospi(float8 x);
float16 __attribute__((overloadable)) cospi(float16 x);
double __attribute__((overloadable)) cospi(double x);
double2 __attribute__((overloadable)) cospi(double2 x);
double3 __attribute__((overloadable)) cospi(double3 x);
double4 __attribute__((overloadable)) cospi(double4 x);
double8 __attribute__((overloadable)) cospi(double8 x);
double16 __attribute__((overloadable)) cospi(double16 x);
float __attribute__((overloadable)) erfc(float x);
float2 __attribute__((overloadable)) erfc(float2 x);
float3 __attribute__((overloadable)) erfc(float3 x);
float4 __attribute__((overloadable)) erfc(float4 x);
float8 __attribute__((overloadable)) erfc(float8 x);
float16 __attribute__((overloadable)) erfc(float16 x);
double __attribute__((overloadable)) erfc(double x);
double2 __attribute__((overloadable)) erfc(double2 x);
double3 __attribute__((overloadable)) erfc(double3 x);
double4 __attribute__((overloadable)) erfc(double4 x);
double8 __attribute__((overloadable)) erfc(double8 x);
double16 __attribute__((overloadable)) erfc(double16 x);
float __attribute__((overloadable)) erf(float x);
float2 __attribute__((overloadable)) erf(float2 x);
float3 __attribute__((overloadable)) erf(float3 x);
float4 __attribute__((overloadable)) erf(float4 x);
float8 __attribute__((overloadable)) erf(float8 x);
float16 __attribute__((overloadable)) erf(float16 x);
double __attribute__((overloadable)) erf(double x);
double2 __attribute__((overloadable)) erf(double2 x);
double3 __attribute__((overloadable)) erf(double3 x);
double4 __attribute__((overloadable)) erf(double4 x);
double8 __attribute__((overloadable)) erf(double8 x);
double16 __attribute__((overloadable)) erf(double16 x);
float __attribute__((overloadable)) exp(float x);
float2 __attribute__((overloadable)) exp(float2 x);
float3 __attribute__((overloadable)) exp(float3 x);
float4 __attribute__((overloadable)) exp(float4 x);
float8 __attribute__((overloadable)) exp(float8 x);
float16 __attribute__((overloadable)) exp(float16 x);
double __attribute__((overloadable)) exp(double x);
double2 __attribute__((overloadable)) exp(double2 x);
double3 __attribute__((overloadable)) exp(double3 x);
double4 __attribute__((overloadable)) exp(double4 x);
double8 __attribute__((overloadable)) exp(double8 x);
double16 __attribute__((overloadable)) exp(double16 x);
float __attribute__((overloadable)) exp2(float x);
float2 __attribute__((overloadable)) exp2(float2 x);
float3 __attribute__((overloadable)) exp2(float3 x);
float4 __attribute__((overloadable)) exp2(float4 x);
float8 __attribute__((overloadable)) exp2(float8 x);
float16 __attribute__((overloadable)) exp2(float16 x);
double __attribute__((overloadable)) exp2(double x);
double2 __attribute__((overloadable)) exp2(double2 x);
double3 __attribute__((overloadable)) exp2(double3 x);
double4 __attribute__((overloadable)) exp2(double4 x);
double8 __attribute__((overloadable)) exp2(double8 x);
double16 __attribute__((overloadable)) exp2(double16 x);
float __attribute__((overloadable)) exp10(float x);
float2 __attribute__((overloadable)) exp10(float2 x);
float3 __attribute__((overloadable)) exp10(float3 x);
float4 __attribute__((overloadable)) exp10(float4 x);
float8 __attribute__((overloadable)) exp10(float8 x);
float16 __attribute__((overloadable)) exp10(float16 x);
double __attribute__((overloadable)) exp10(double x);
double2 __attribute__((overloadable)) exp10(double2 x);
double3 __attribute__((overloadable)) exp10(double3 x);
double4 __attribute__((overloadable)) exp10(double4 x);
double8 __attribute__((overloadable)) exp10(double8 x);
double16 __attribute__((overloadable)) exp10(double16 x);
float __attribute__((overloadable)) expm1(float x);
float2 __attribute__((overloadable)) expm1(float2 x);
float3 __attribute__((overloadable)) expm1(float3 x);
float4 __attribute__((overloadable)) expm1(float4 x);
float8 __attribute__((overloadable)) expm1(float8 x);
float16 __attribute__((overloadable)) expm1(float16 x);
double __attribute__((overloadable)) expm1(double x);
double2 __attribute__((overloadable)) expm1(double2 x);
double3 __attribute__((overloadable)) expm1(double3 x);
double4 __attribute__((overloadable)) expm1(double4 x);
double8 __attribute__((overloadable)) expm1(double8 x);
double16 __attribute__((overloadable)) expm1(double16 x);
float __attribute__((overloadable)) fabs(float x);
float2 __attribute__((overloadable)) fabs(float2 x);
float3 __attribute__((overloadable)) fabs(float3 x);
float4 __attribute__((overloadable)) fabs(float4 x);
float8 __attribute__((overloadable)) fabs(float8 x);
float16 __attribute__((overloadable)) fabs(float16 x);
double __attribute__((overloadable)) fabs(double x);
double2 __attribute__((overloadable)) fabs(double2 x);
double3 __attribute__((overloadable)) fabs(double3 x);
double4 __attribute__((overloadable)) fabs(double4 x);
double8 __attribute__((overloadable)) fabs(double8 x);
double16 __attribute__((overloadable)) fabs(double16 x);
float __attribute__((overloadable)) fdim(float x, float y);
float2 __attribute__((overloadable)) fdim(float2 x, float2 y);
float3 __attribute__((overloadable)) fdim(float3 x, float3 y);
float4 __attribute__((overloadable)) fdim(float4 x, float4 y);
float8 __attribute__((overloadable)) fdim(float8 x, float8 y);
float16 __attribute__((overloadable)) fdim(float16 x, float16 y);
double __attribute__((overloadable)) fdim(double x, double y);
double2 __attribute__((overloadable)) fdim(double2 x, double2 y);
double3 __attribute__((overloadable)) fdim(double3 x, double3 y);
double4 __attribute__((overloadable)) fdim(double4 x, double4 y);
double8 __attribute__((overloadable)) fdim(double8 x, double8 y);
double16 __attribute__((overloadable)) fdim(double16 x, double16 y);
float __attribute__((overloadable)) floor(float x);
float2 __attribute__((overloadable)) floor(float2 x);
float3 __attribute__((overloadable)) floor(float3 x);
float4 __attribute__((overloadable)) floor(float4 x);
float8 __attribute__((overloadable)) floor(float8 x);
float16 __attribute__((overloadable)) floor(float16 x);
double __attribute__((overloadable)) floor(double x);
double2 __attribute__((overloadable)) floor(double2 x);
double3 __attribute__((overloadable)) floor(double3 x);
double4 __attribute__((overloadable)) floor(double4 x);
double8 __attribute__((overloadable)) floor(double8 x);
double16 __attribute__((overloadable)) floor(double16 x);
float __attribute__((overloadable)) fma(float x, float y, float z);
float2 __attribute__((overloadable)) fma(float2 x, float2 y, float2 z);
float3 __attribute__((overloadable)) fma(float3 x, float3 y, float3 z);
float4 __attribute__((overloadable)) fma(float4 x, float4 y, float4 z);
float8 __attribute__((overloadable)) fma(float8 x, float8 y, float8 z);
float16 __attribute__((overloadable)) fma(float16 x, float16 y, float16 z);
double __attribute__((overloadable)) fma(double x, double y, double z);
double2 __attribute__((overloadable)) fma(double2 x, double2 y, double2 z);
double3 __attribute__((overloadable)) fma(double3 x, double3 y, double3 z);
double4 __attribute__((overloadable)) fma(double4 x, double4 y, double4 z);
double8 __attribute__((overloadable)) fma(double8 x, double8 y, double8 z);
double16 __attribute__((overloadable)) fma(double16 x, double16 y, double16 z);
float __attribute__((overloadable)) fmax(float x, float y);
float2 __attribute__((overloadable)) fmax(float2 x, float2 y);
float3 __attribute__((overloadable)) fmax(float3 x, float3 y);
float4 __attribute__((overloadable)) fmax(float4 x, float4 y);
float8 __attribute__((overloadable)) fmax(float8 x, float8 y);
float16 __attribute__((overloadable)) fmax(float16 x, float16 y);
double __attribute__((overloadable)) fmax(double x, double y);
double2 __attribute__((overloadable)) fmax(double2 x, double2 y);
double3 __attribute__((overloadable)) fmax(double3 x, double3 y);
double4 __attribute__((overloadable)) fmax(double4 x, double4 y);
double8 __attribute__((overloadable)) fmax(double8 x, double8 y);
double16 __attribute__((overloadable)) fmax(double16 x, double16 y);
float2 __attribute__((overloadable)) fmax(float2 x, float y);
float3 __attribute__((overloadable)) fmax(float3 x, float y);
float4 __attribute__((overloadable)) fmax(float4 x, float y);
float8 __attribute__((overloadable)) fmax(float8 x, float y);
float16 __attribute__((overloadable)) fmax(float16 x, float y);
double2 __attribute__((overloadable)) fmax(double2 x, double y);
double3 __attribute__((overloadable)) fmax(double3 x, double y);
double4 __attribute__((overloadable)) fmax(double4 x, double y);
double8 __attribute__((overloadable)) fmax(double8 x, double y);
double16 __attribute__((overloadable)) fmax(double16 x, double y);
float __attribute__((overloadable)) fmin(float x, float y);
float2 __attribute__((overloadable)) fmin(float2 x, float2 y);
float3 __attribute__((overloadable)) fmin(float3 x, float3 y);
float4 __attribute__((overloadable)) fmin(float4 x, float4 y);
float8 __attribute__((overloadable)) fmin(float8 x, float8 y);
float16 __attribute__((overloadable)) fmin(float16 x, float16 y);
double __attribute__((overloadable)) fmin(double x, double y);
double2 __attribute__((overloadable)) fmin(double2 x, double2 y);
double3 __attribute__((overloadable)) fmin(double3 x, double3 y);
double4 __attribute__((overloadable)) fmin(double4 x, double4 y);
double8 __attribute__((overloadable)) fmin(double8 x, double8 y);
double16 __attribute__((overloadable)) fmin(double16 x, double16 y);
float2 __attribute__((overloadable)) fmin(float2 x, float y);
float3 __attribute__((overloadable)) fmin(float3 x, float y);
float4 __attribute__((overloadable)) fmin(float4 x, float y);
float8 __attribute__((overloadable)) fmin(float8 x, float y);
float16 __attribute__((overloadable)) fmin(float16 x, float y);
double2 __attribute__((overloadable)) fmin(double2 x, double y);
double3 __attribute__((overloadable)) fmin(double3 x, double y);
double4 __attribute__((overloadable)) fmin(double4 x, double y);
double8 __attribute__((overloadable)) fmin(double8 x, double y);
double16 __attribute__((overloadable)) fmin(double16 x, double y);
float __attribute__((overloadable)) fmod(float x, float y);
float2 __attribute__((overloadable)) fmod(float2 x, float2 y);
float3 __attribute__((overloadable)) fmod(float3 x, float3 y);
float4 __attribute__((overloadable)) fmod(float4 x, float4 y);
float8 __attribute__((overloadable)) fmod(float8 x, float8 y);
float16 __attribute__((overloadable)) fmod(float16 x, float16 y);
double __attribute__((overloadable)) fmod(double x, double y);
double2 __attribute__((overloadable)) fmod(double2 x, double2 y);
double3 __attribute__((overloadable)) fmod(double3 x, double3 y);
double4 __attribute__((overloadable)) fmod(double4 x, double4 y);
double8 __attribute__((overloadable)) fmod(double8 x, double8 y);
double16 __attribute__((overloadable)) fmod(double16 x, double16 y);
float __attribute__((overloadable)) fract(float x, __global float* y);
float2 __attribute__((overloadable)) fract(float2 x, __global float2* y);
float3 __attribute__((overloadable)) fract(float3 x, __global float3* y);
float4 __attribute__((overloadable)) fract(float4 x, __global float4* y);
float8 __attribute__((overloadable)) fract(float8 x, __global float8* y);
float16 __attribute__((overloadable)) fract(float16 x, __global float16* y);
double __attribute__((overloadable)) fract(double x, __global double* y);
double2 __attribute__((overloadable)) fract(double2 x, __global double2* y);
double3 __attribute__((overloadable)) fract(double3 x, __global double3* y);
double4 __attribute__((overloadable)) fract(double4 x, __global double4* y);
double8 __attribute__((overloadable)) fract(double8 x, __global double8* y);
double16 __attribute__((overloadable)) fract(double16 x, __global double16* y);
float __attribute__((overloadable)) fract(float x, __local float* y);
float2 __attribute__((overloadable)) fract(float2 x, __local float2* y);
float3 __attribute__((overloadable)) fract(float3 x, __local float3* y);
float4 __attribute__((overloadable)) fract(float4 x, __local float4* y);
float8 __attribute__((overloadable)) fract(float8 x, __local float8* y);
float16 __attribute__((overloadable)) fract(float16 x, __local float16* y);
double __attribute__((overloadable)) fract(double x, __local double* y);
double2 __attribute__((overloadable)) fract(double2 x, __local double2* y);
double3 __attribute__((overloadable)) fract(double3 x, __local double3* y);
double4 __attribute__((overloadable)) fract(double4 x, __local double4* y);
double8 __attribute__((overloadable)) fract(double8 x, __local double8* y);
double16 __attribute__((overloadable)) fract(double16 x, __local double16* y);
float __attribute__((overloadable)) fract(float x, __private float* y);
float2 __attribute__((overloadable)) fract(float2 x, __private float2* y);
float3 __attribute__((overloadable)) fract(float3 x, __private float3* y);
float4 __attribute__((overloadable)) fract(float4 x, __private float4* y);
float8 __attribute__((overloadable)) fract(float8 x, __private float8* y);
float16 __attribute__((overloadable)) fract(float16 x, __private float16* y);
double __attribute__((overloadable)) fract(double x, __private double* y);
double2 __attribute__((overloadable)) fract(double2 x, __private double2* y);
double3 __attribute__((overloadable)) fract(double3 x, __private double3* y);
double4 __attribute__((overloadable)) fract(double4 x, __private double4* y);
double8 __attribute__((overloadable)) fract(double8 x, __private double8* y);
double16 __attribute__((overloadable)) fract(double16 x, __private double16* y);
float __attribute__((overloadable)) frexp(float x, __global int* y);
float2 __attribute__((overloadable)) frexp(float2 x, __global int2* y);
float3 __attribute__((overloadable)) frexp(float3 x, __global int3* y);
float4 __attribute__((overloadable)) frexp(float4 x, __global int4* y);
float8 __attribute__((overloadable)) frexp(float8 x, __global int8* y);
float16 __attribute__((overloadable)) frexp(float16 x, __global int16* y);
float __attribute__((overloadable)) frexp(float x, __local int* y);
float2 __attribute__((overloadable)) frexp(float2 x, __local int2* y);
float3 __attribute__((overloadable)) frexp(float3 x, __local int3* y);
float4 __attribute__((overloadable)) frexp(float4 x, __local int4* y);
float8 __attribute__((overloadable)) frexp(float8 x, __local int8* y);
float16 __attribute__((overloadable)) frexp(float16 x, __local int16* y);
float __attribute__((overloadable)) frexp(float x, __private int* y);
float2 __attribute__((overloadable)) frexp(float2 x, __private int2* y);
float3 __attribute__((overloadable)) frexp(float3 x, __private int3* y);
float4 __attribute__((overloadable)) frexp(float4 x, __private int4* y);
float8 __attribute__((overloadable)) frexp(float8 x, __private int8* y);
float16 __attribute__((overloadable)) frexp(float16 x, __private int16* y);
float __attribute__((overloadable)) frexp(float x, __global int2* y);
float __attribute__((overloadable)) frexp(float x, __global int3* y);
float __attribute__((overloadable)) frexp(float x, __global int4* y);
float __attribute__((overloadable)) frexp(float x, __global int8* y);
float __attribute__((overloadable)) frexp(float x, __global int16* y);
float __attribute__((overloadable)) frexp(float x, __local int2* y);
float __attribute__((overloadable)) frexp(float x, __local int3* y);
float __attribute__((overloadable)) frexp(float x, __local int4* y);
float __attribute__((overloadable)) frexp(float x, __local int8* y);
float __attribute__((overloadable)) frexp(float x, __local int16* y);
float __attribute__((overloadable)) frexp(float x, __private int2* y);
float __attribute__((overloadable)) frexp(float x, __private int3* y);
float __attribute__((overloadable)) frexp(float x, __private int4* y);
float __attribute__((overloadable)) frexp(float x, __private int8* y);
float __attribute__((overloadable)) frexp(float x, __private int16* y);
double __attribute__((overloadable)) frexp(double x, __global int* y);
double2 __attribute__((overloadable)) frexp(double2 x, __global int2* y);
double3 __attribute__((overloadable)) frexp(double3 x, __global int3* y);
double4 __attribute__((overloadable)) frexp(double4 x, __global int4* y);
double8 __attribute__((overloadable)) frexp(double8 x, __global int8* y);
double16 __attribute__((overloadable)) frexp(double16 x, __global int16* y);
double __attribute__((overloadable)) frexp(double x, __local int* y);
double2 __attribute__((overloadable)) frexp(double2 x, __local int2* y);
double3 __attribute__((overloadable)) frexp(double3 x, __local int3* y);
double4 __attribute__((overloadable)) frexp(double4 x, __local int4* y);
double8 __attribute__((overloadable)) frexp(double8 x, __local int8* y);
double16 __attribute__((overloadable)) frexp(double16 x, __local int16* y);
double __attribute__((overloadable)) frexp(double x, __private int* y);
double2 __attribute__((overloadable)) frexp(double2 x, __private int2* y);
double3 __attribute__((overloadable)) frexp(double3 x, __private int3* y);
double4 __attribute__((overloadable)) frexp(double4 x, __private int4* y);
double8 __attribute__((overloadable)) frexp(double8 x, __private int8* y);
double16 __attribute__((overloadable)) frexp(double16 x, __private int16* y);
double __attribute__((overloadable)) frexp(double x, __global int2* y);
double __attribute__((overloadable)) frexp(double x, __global int3* y);
double __attribute__((overloadable)) frexp(double x, __global int4* y);
double __attribute__((overloadable)) frexp(double x, __global int8* y);
double __attribute__((overloadable)) frexp(double x, __global int16* y);
double __attribute__((overloadable)) frexp(double x, __local int2* y);
double __attribute__((overloadable)) frexp(double x, __local int3* y);
double __attribute__((overloadable)) frexp(double x, __local int4* y);
double __attribute__((overloadable)) frexp(double x, __local int8* y);
double __attribute__((overloadable)) frexp(double x, __local int16* y);
double __attribute__((overloadable)) frexp(double x, __private int2* y);
double __attribute__((overloadable)) frexp(double x, __private int3* y);
double __attribute__((overloadable)) frexp(double x, __private int4* y);
double __attribute__((overloadable)) frexp(double x, __private int8* y);
double __attribute__((overloadable)) frexp(double x, __private int16* y);
float __attribute__((overloadable)) hypot(float x, float y);
float2 __attribute__((overloadable)) hypot(float2 x, float2 y);
float3 __attribute__((overloadable)) hypot(float3 x, float3 y);
float4 __attribute__((overloadable)) hypot(float4 x, float4 y);
float8 __attribute__((overloadable)) hypot(float8 x, float8 y);
float16 __attribute__((overloadable)) hypot(float16 x, float16 y);
double __attribute__((overloadable)) hypot(double x, double y);
double2 __attribute__((overloadable)) hypot(double2 x, double2 y);
double3 __attribute__((overloadable)) hypot(double3 x, double3 y);
double4 __attribute__((overloadable)) hypot(double4 x, double4 y);
double8 __attribute__((overloadable)) hypot(double8 x, double8 y);
double16 __attribute__((overloadable)) hypot(double16 x, double16 y);
int __attribute__((overloadable)) ilogb(float x);
int2 __attribute__((overloadable)) ilogb(float2 x);
int3 __attribute__((overloadable)) ilogb(float3 x);
int4 __attribute__((overloadable)) ilogb(float4 x);
int8 __attribute__((overloadable)) ilogb(float8 x);
int16 __attribute__((overloadable)) ilogb(float16 x);
int __attribute__((overloadable)) ilogb(double x);
int2 __attribute__((overloadable)) ilogb(double2 x);
int3 __attribute__((overloadable)) ilogb(double3 x);
int4 __attribute__((overloadable)) ilogb(double4 x);
int8 __attribute__((overloadable)) ilogb(double8 x);
int16 __attribute__((overloadable)) ilogb(double16 x);
float __attribute__((overloadable)) ldexp(float x, int y);
float2 __attribute__((overloadable)) ldexp(float2 x, int2 y);
float3 __attribute__((overloadable)) ldexp(float3 x, int3 y);
float4 __attribute__((overloadable)) ldexp(float4 x, int4 y);
float8 __attribute__((overloadable)) ldexp(float8 x, int8 y);
float16 __attribute__((overloadable)) ldexp(float16 x, int16 y);
float2 __attribute__((overloadable)) ldexp(float2 x, int y);
float3 __attribute__((overloadable)) ldexp(float3 x, int y);
float4 __attribute__((overloadable)) ldexp(float4 x, int y);
float8 __attribute__((overloadable)) ldexp(float8 x, int y);
float16 __attribute__((overloadable)) ldexp(float16 x, int y);
double __attribute__((overloadable)) ldexp(double x, int y);
double2 __attribute__((overloadable)) ldexp(double2 x, int2 y);
double3 __attribute__((overloadable)) ldexp(double3 x, int3 y);
double4 __attribute__((overloadable)) ldexp(double4 x, int4 y);
double8 __attribute__((overloadable)) ldexp(double8 x, int8 y);
double16 __attribute__((overloadable)) ldexp(double16 x, int16 y);
double2 __attribute__((overloadable)) ldexp(double2 x, int y);
double3 __attribute__((overloadable)) ldexp(double3 x, int y);
double4 __attribute__((overloadable)) ldexp(double4 x, int y);
double8 __attribute__((overloadable)) ldexp(double8 x, int y);
double16 __attribute__((overloadable)) ldexp(double16 x, int y);
float __attribute__((overloadable)) lgamma(float x);
float2 __attribute__((overloadable)) lgamma(float2 x);
float3 __attribute__((overloadable)) lgamma(float3 x);
float4 __attribute__((overloadable)) lgamma(float4 x);
float8 __attribute__((overloadable)) lgamma(float8 x);
float16 __attribute__((overloadable)) lgamma(float16 x);
double __attribute__((overloadable)) lgamma(double x);
double2 __attribute__((overloadable)) lgamma(double2 x);
double3 __attribute__((overloadable)) lgamma(double3 x);
double4 __attribute__((overloadable)) lgamma(double4 x);
double8 __attribute__((overloadable)) lgamma(double8 x);
double16 __attribute__((overloadable)) lgamma(double16 x);
float __attribute__((overloadable)) lgamma_r(float x, __global int* y);
float2 __attribute__((overloadable)) lgamma_r(float2 x, __global int2* y);
float3 __attribute__((overloadable)) lgamma_r(float3 x, __global int3* y);
float4 __attribute__((overloadable)) lgamma_r(float4 x, __global int4* y);
float8 __attribute__((overloadable)) lgamma_r(float8 x, __global int8* y);
float16 __attribute__((overloadable)) lgamma_r(float16 x, __global int16* y);
float __attribute__((overloadable)) lgamma_r(float x, __local int* y);
float2 __attribute__((overloadable)) lgamma_r(float2 x, __local int2* y);
float3 __attribute__((overloadable)) lgamma_r(float3 x, __local int3* y);
float4 __attribute__((overloadable)) lgamma_r(float4 x, __local int4* y);
float8 __attribute__((overloadable)) lgamma_r(float8 x, __local int8* y);
float16 __attribute__((overloadable)) lgamma_r(float16 x, __local int16* y);
float __attribute__((overloadable)) lgamma_r(float x, __private int* y);
float2 __attribute__((overloadable)) lgamma_r(float2 x, __private int2* y);
float3 __attribute__((overloadable)) lgamma_r(float3 x, __private int3* y);
float4 __attribute__((overloadable)) lgamma_r(float4 x, __private int4* y);
float8 __attribute__((overloadable)) lgamma_r(float8 x, __private int8* y);
float16 __attribute__((overloadable)) lgamma_r(float16 x, __private int16* y);
double __attribute__((overloadable)) lgamma_r(double x, __global int* y);
double2 __attribute__((overloadable)) lgamma_r(double2 x, __global int2* y);
double3 __attribute__((overloadable)) lgamma_r(double3 x, __global int3* y);
double4 __attribute__((overloadable)) lgamma_r(double4 x, __global int4* y);
double8 __attribute__((overloadable)) lgamma_r(double8 x, __global int8* y);
double16 __attribute__((overloadable)) lgamma_r(double16 x, __global int16* y);
double __attribute__((overloadable)) lgamma_r(double x, __local int* y);
double2 __attribute__((overloadable)) lgamma_r(double2 x, __local int2* y);
double3 __attribute__((overloadable)) lgamma_r(double3 x, __local int3* y);
double4 __attribute__((overloadable)) lgamma_r(double4 x, __local int4* y);
double8 __attribute__((overloadable)) lgamma_r(double8 x, __local int8* y);
double16 __attribute__((overloadable)) lgamma_r(double16 x, __local int16* y);
double __attribute__((overloadable)) lgamma_r(double x, __private int* y);
double2 __attribute__((overloadable)) lgamma_r(double2 x, __private int2* y);
double3 __attribute__((overloadable)) lgamma_r(double3 x, __private int3* y);
double4 __attribute__((overloadable)) lgamma_r(double4 x, __private int4* y);
double8 __attribute__((overloadable)) lgamma_r(double8 x, __private int8* y);
double16 __attribute__((overloadable)) lgamma_r(double16 x, __private int16* y);
float __attribute__((overloadable)) log(float x);
float2 __attribute__((overloadable)) log(float2 x);
float3 __attribute__((overloadable)) log(float3 x);
float4 __attribute__((overloadable)) log(float4 x);
float8 __attribute__((overloadable)) log(float8 x);
float16 __attribute__((overloadable)) log(float16 x);
double __attribute__((overloadable)) log(double x);
double2 __attribute__((overloadable)) log(double2 x);
double3 __attribute__((overloadable)) log(double3 x);
double4 __attribute__((overloadable)) log(double4 x);
double8 __attribute__((overloadable)) log(double8 x);
double16 __attribute__((overloadable)) log(double16 x);
float __attribute__((overloadable)) log2(float x);
float2 __attribute__((overloadable)) log2(float2 x);
float3 __attribute__((overloadable)) log2(float3 x);
float4 __attribute__((overloadable)) log2(float4 x);
float8 __attribute__((overloadable)) log2(float8 x);
float16 __attribute__((overloadable)) log2(float16 x);
double __attribute__((overloadable)) log2(double x);
double2 __attribute__((overloadable)) log2(double2 x);
double3 __attribute__((overloadable)) log2(double3 x);
double4 __attribute__((overloadable)) log2(double4 x);
double8 __attribute__((overloadable)) log2(double8 x);
double16 __attribute__((overloadable)) log2(double16 x);
float __attribute__((overloadable)) log10(float x);
float2 __attribute__((overloadable)) log10(float2 x);
float3 __attribute__((overloadable)) log10(float3 x);
float4 __attribute__((overloadable)) log10(float4 x);
float8 __attribute__((overloadable)) log10(float8 x);
float16 __attribute__((overloadable)) log10(float16 x);
double __attribute__((overloadable)) log10(double x);
double2 __attribute__((overloadable)) log10(double2 x);
double3 __attribute__((overloadable)) log10(double3 x);
double4 __attribute__((overloadable)) log10(double4 x);
double8 __attribute__((overloadable)) log10(double8 x);
double16 __attribute__((overloadable)) log10(double16 x);
float __attribute__((overloadable)) log1p(float x);
float2 __attribute__((overloadable)) log1p(float2 x);
float3 __attribute__((overloadable)) log1p(float3 x);
float4 __attribute__((overloadable)) log1p(float4 x);
float8 __attribute__((overloadable)) log1p(float8 x);
float16 __attribute__((overloadable)) log1p(float16 x);
double __attribute__((overloadable)) log1p(double x);
double2 __attribute__((overloadable)) log1p(double2 x);
double3 __attribute__((overloadable)) log1p(double3 x);
double4 __attribute__((overloadable)) log1p(double4 x);
double8 __attribute__((overloadable)) log1p(double8 x);
double16 __attribute__((overloadable)) log1p(double16 x);
float __attribute__((overloadable)) logb(float x);
float2 __attribute__((overloadable)) logb(float2 x);
float3 __attribute__((overloadable)) logb(float3 x);
float4 __attribute__((overloadable)) logb(float4 x);
float8 __attribute__((overloadable)) logb(float8 x);
float16 __attribute__((overloadable)) logb(float16 x);
double __attribute__((overloadable)) logb(double x);
double2 __attribute__((overloadable)) logb(double2 x);
double3 __attribute__((overloadable)) logb(double3 x);
double4 __attribute__((overloadable)) logb(double4 x);
double8 __attribute__((overloadable)) logb(double8 x);
double16 __attribute__((overloadable)) logb(double16 x);
float __attribute__((overloadable)) mad(float x, float y, float z);
float2 __attribute__((overloadable)) mad(float2 x, float2 y, float2 z);
float3 __attribute__((overloadable)) mad(float3 x, float3 y, float3 z);
float4 __attribute__((overloadable)) mad(float4 x, float4 y, float4 z);
float8 __attribute__((overloadable)) mad(float8 x, float8 y, float8 z);
float16 __attribute__((overloadable)) mad(float16 x, float16 y, float16 z);
double __attribute__((overloadable)) mad(double x, double y, double z);
double2 __attribute__((overloadable)) mad(double2 x, double2 y, double2 z);
double3 __attribute__((overloadable)) mad(double3 x, double3 y, double3 z);
double4 __attribute__((overloadable)) mad(double4 x, double4 y, double4 z);
double8 __attribute__((overloadable)) mad(double8 x, double8 y, double8 z);
double16 __attribute__((overloadable)) mad(double16 x, double16 y, double16 z);
float __attribute__((overloadable)) maxmag(float x, float y);
float2 __attribute__((overloadable)) maxmag(float2 x, float2 y);
float3 __attribute__((overloadable)) maxmag(float3 x, float3 y);
float4 __attribute__((overloadable)) maxmag(float4 x, float4 y);
float8 __attribute__((overloadable)) maxmag(float8 x, float8 y);
float16 __attribute__((overloadable)) maxmag(float16 x, float16 y);
double __attribute__((overloadable)) maxmag(double x, double y);
double2 __attribute__((overloadable)) maxmag(double2 x, double2 y);
double3 __attribute__((overloadable)) maxmag(double3 x, double3 y);
double4 __attribute__((overloadable)) maxmag(double4 x, double4 y);
double8 __attribute__((overloadable)) maxmag(double8 x, double8 y);
double16 __attribute__((overloadable)) maxmag(double16 x, double16 y);
float __attribute__((overloadable)) minmag(float x, float y);
float2 __attribute__((overloadable)) minmag(float2 x, float2 y);
float3 __attribute__((overloadable)) minmag(float3 x, float3 y);
float4 __attribute__((overloadable)) minmag(float4 x, float4 y);
float8 __attribute__((overloadable)) minmag(float8 x, float8 y);
float16 __attribute__((overloadable)) minmag(float16 x, float16 y);
double __attribute__((overloadable)) minmag(double x, double y);
double2 __attribute__((overloadable)) minmag(double2 x, double2 y);
double3 __attribute__((overloadable)) minmag(double3 x, double3 y);
double4 __attribute__((overloadable)) minmag(double4 x, double4 y);
double8 __attribute__((overloadable)) minmag(double8 x, double8 y);
double16 __attribute__((overloadable)) minmag(double16 x, double16 y);
float __attribute__((overloadable)) modf(float x, __global float* y);
float2 __attribute__((overloadable)) modf(float2 x, __global float2* y);
float3 __attribute__((overloadable)) modf(float3 x, __global float3* y);
float4 __attribute__((overloadable)) modf(float4 x, __global float4* y);
float8 __attribute__((overloadable)) modf(float8 x, __global float8* y);
float16 __attribute__((overloadable)) modf(float16 x, __global float16* y);
double __attribute__((overloadable)) modf(double x, __global double* y);
double2 __attribute__((overloadable)) modf(double2 x, __global double2* y);
double3 __attribute__((overloadable)) modf(double3 x, __global double3* y);
double4 __attribute__((overloadable)) modf(double4 x, __global double4* y);
double8 __attribute__((overloadable)) modf(double8 x, __global double8* y);
double16 __attribute__((overloadable)) modf(double16 x, __global double16* y);
float __attribute__((overloadable)) modf(float x, __local float* y);
float2 __attribute__((overloadable)) modf(float2 x, __local float2* y);
float3 __attribute__((overloadable)) modf(float3 x, __local float3* y);
float4 __attribute__((overloadable)) modf(float4 x, __local float4* y);
float8 __attribute__((overloadable)) modf(float8 x, __local float8* y);
float16 __attribute__((overloadable)) modf(float16 x, __local float16* y);
double __attribute__((overloadable)) modf(double x, __local double* y);
double2 __attribute__((overloadable)) modf(double2 x, __local double2* y);
double3 __attribute__((overloadable)) modf(double3 x, __local double3* y);
double4 __attribute__((overloadable)) modf(double4 x, __local double4* y);
double8 __attribute__((overloadable)) modf(double8 x, __local double8* y);
double16 __attribute__((overloadable)) modf(double16 x, __local double16* y);
float __attribute__((overloadable)) modf(float x, __private float* y);
float2 __attribute__((overloadable)) modf(float2 x, __private float2* y);
float3 __attribute__((overloadable)) modf(float3 x, __private float3* y);
float4 __attribute__((overloadable)) modf(float4 x, __private float4* y);
float8 __attribute__((overloadable)) modf(float8 x, __private float8* y);
float16 __attribute__((overloadable)) modf(float16 x, __private float16* y);
double __attribute__((overloadable)) modf(double x, __private double* y);
double2 __attribute__((overloadable)) modf(double2 x, __private double2* y);
double3 __attribute__((overloadable)) modf(double3 x, __private double3* y);
double4 __attribute__((overloadable)) modf(double4 x, __private double4* y);
double8 __attribute__((overloadable)) modf(double8 x, __private double8* y);
double16 __attribute__((overloadable)) modf(double16 x, __private double16* y);
float __attribute__((overloadable)) nan(uint x);
float2 __attribute__((overloadable)) nan(uint2 x);
float3 __attribute__((overloadable)) nan(uint3 x);
float4 __attribute__((overloadable)) nan(uint4 x);
float8 __attribute__((overloadable)) nan(uint8 x);
float16 __attribute__((overloadable)) nan(uint16 x);
float __attribute__((overloadable)) nextafter(float x, float y);
float2 __attribute__((overloadable)) nextafter(float2 x, float2 y);
float3 __attribute__((overloadable)) nextafter(float3 x, float3 y);
float4 __attribute__((overloadable)) nextafter(float4 x, float4 y);
float8 __attribute__((overloadable)) nextafter(float8 x, float8 y);
float16 __attribute__((overloadable)) nextafter(float16 x, float16 y);
double __attribute__((overloadable)) nextafter(double x, double y);
double2 __attribute__((overloadable)) nextafter(double2 x, double2 y);
double3 __attribute__((overloadable)) nextafter(double3 x, double3 y);
double4 __attribute__((overloadable)) nextafter(double4 x, double4 y);
double8 __attribute__((overloadable)) nextafter(double8 x, double8 y);
double16 __attribute__((overloadable)) nextafter(double16 x, double16 y);
float __attribute__((overloadable)) pow(float x, float y);
float2 __attribute__((overloadable)) pow(float2 x, float2 y);
float3 __attribute__((overloadable)) pow(float3 x, float3 y);
float4 __attribute__((overloadable)) pow(float4 x, float4 y);
float8 __attribute__((overloadable)) pow(float8 x, float8 y);
float16 __attribute__((overloadable)) pow(float16 x, float16 y);
double __attribute__((overloadable)) pow(double x, double y);
double2 __attribute__((overloadable)) pow(double2 x, double2 y);
double3 __attribute__((overloadable)) pow(double3 x, double3 y);
double4 __attribute__((overloadable)) pow(double4 x, double4 y);
double8 __attribute__((overloadable)) pow(double8 x, double8 y);
double16 __attribute__((overloadable)) pow(double16 x, double16 y);
float __attribute__((overloadable)) pown(float x, int y);
float2 __attribute__((overloadable)) pown(float2 x, int2 y);
float3 __attribute__((overloadable)) pown(float3 x, int3 y);
float4 __attribute__((overloadable)) pown(float4 x, int4 y);
float8 __attribute__((overloadable)) pown(float8 x, int8 y);
float16 __attribute__((overloadable)) pown(float16 x, int16 y);
double __attribute__((overloadable)) pown(double x, int y);
double2 __attribute__((overloadable)) pown(double2 x, int2 y);
double3 __attribute__((overloadable)) pown(double3 x, int3 y);
double4 __attribute__((overloadable)) pown(double4 x, int4 y);
double8 __attribute__((overloadable)) pown(double8 x, int8 y);
double16 __attribute__((overloadable)) pown(double16 x, int16 y);
float __attribute__((overloadable)) powr(float x, float y);
float2 __attribute__((overloadable)) powr(float2 x, float2 y);
float3 __attribute__((overloadable)) powr(float3 x, float3 y);
float4 __attribute__((overloadable)) powr(float4 x, float4 y);
float8 __attribute__((overloadable)) powr(float8 x, float8 y);
float16 __attribute__((overloadable)) powr(float16 x, float16 y);
double __attribute__((overloadable)) powr(double x, double y);
double2 __attribute__((overloadable)) powr(double2 x, double2 y);
double3 __attribute__((overloadable)) powr(double3 x, double3 y);
double4 __attribute__((overloadable)) powr(double4 x, double4 y);
double8 __attribute__((overloadable)) powr(double8 x, double8 y);
double16 __attribute__((overloadable)) powr(double16 x, double16 y);
float __attribute__((overloadable)) remainder(float x, float y);
float2 __attribute__((overloadable)) remainder(float2 x, float2 y);
float3 __attribute__((overloadable)) remainder(float3 x, float3 y);
float4 __attribute__((overloadable)) remainder(float4 x, float4 y);
float8 __attribute__((overloadable)) remainder(float8 x, float8 y);
float16 __attribute__((overloadable)) remainder(float16 x, float16 y);
double __attribute__((overloadable)) remainder(double x, double y);
double2 __attribute__((overloadable)) remainder(double2 x, double2 y);
double3 __attribute__((overloadable)) remainder(double3 x, double3 y);
double4 __attribute__((overloadable)) remainder(double4 x, double4 y);
double8 __attribute__((overloadable)) remainder(double8 x, double8 y);
double16 __attribute__((overloadable)) remainder(double16 x, double16 y);
float __attribute__((overloadable)) remquo(float x, float y, __global int* z);
float2 __attribute__((overloadable)) remquo(float2 x, float2 y, __global int2* z);
float3 __attribute__((overloadable)) remquo(float3 x, float3 y, __global int3* z);
float4 __attribute__((overloadable)) remquo(float4 x, float4 y, __global int4* z);
float8 __attribute__((overloadable)) remquo(float8 x, float8 y, __global int8* z);
float16 __attribute__((overloadable)) remquo(float16 x, float16 y, __global int16* z);
float __attribute__((overloadable)) remquo(float x, float y, __local int* z);
float2 __attribute__((overloadable)) remquo(float2 x, float2 y, __local int2* z);
float3 __attribute__((overloadable)) remquo(float3 x, float3 y, __local int3* z);
float4 __attribute__((overloadable)) remquo(float4 x, float4 y, __local int4* z);
float8 __attribute__((overloadable)) remquo(float8 x, float8 y, __local int8* z);
float16 __attribute__((overloadable)) remquo(float16 x, float16 y, __local int16* z);
float __attribute__((overloadable)) remquo(float x, float y, __private int* z);
float2 __attribute__((overloadable)) remquo(float2 x, float2 y, __private int2* z);
float3 __attribute__((overloadable)) remquo(float3 x, float3 y, __private int3* z);
float4 __attribute__((overloadable)) remquo(float4 x, float4 y, __private int4* z);
float8 __attribute__((overloadable)) remquo(float8 x, float8 y, __private int8* z);
float16 __attribute__((overloadable)) remquo(float16 x, float16 y, __private int16* z);
double __attribute__((overloadable)) remquo(double x, double y, __global int* z);
double2 __attribute__((overloadable)) remquo(double2 x, double2 y, __global int2* z);
double3 __attribute__((overloadable)) remquo(double3 x, double3 y, __global int3* z);
double4 __attribute__((overloadable)) remquo(double4 x, double4 y, __global int4* z);
double8 __attribute__((overloadable)) remquo(double8 x, double8 y, __global int8* z);
double16 __attribute__((overloadable)) remquo(double16 x, double16 y, __global int16* z);
double __attribute__((overloadable)) remquo(double x, double y, __local int* z);
double2 __attribute__((overloadable)) remquo(double2 x, double2 y, __local int2* z);
double3 __attribute__((overloadable)) remquo(double3 x, double3 y, __local int3* z);
double4 __attribute__((overloadable)) remquo(double4 x, double4 y, __local int4* z);
double8 __attribute__((overloadable)) remquo(double8 x, double8 y, __local int8* z);
double16 __attribute__((overloadable)) remquo(double16 x, double16 y, __local int16* z);
double __attribute__((overloadable)) remquo(double x, double y, __private int* z);
double2 __attribute__((overloadable)) remquo(double2 x, double2 y, __private int2* z);
double3 __attribute__((overloadable)) remquo(double3 x, double3 y, __private int3* z);
double4 __attribute__((overloadable)) remquo(double4 x, double4 y, __private int4* z);
double8 __attribute__((overloadable)) remquo(double8 x, double8 y, __private int8* z);
double16 __attribute__((overloadable)) remquo(double16 x, double16 y, __private int16* z);
float __attribute__((overloadable)) rint(float x);
float2 __attribute__((overloadable)) rint(float2 x);
float3 __attribute__((overloadable)) rint(float3 x);
float4 __attribute__((overloadable)) rint(float4 x);
float8 __attribute__((overloadable)) rint(float8 x);
float16 __attribute__((overloadable)) rint(float16 x);
double __attribute__((overloadable)) rint(double x);
double2 __attribute__((overloadable)) rint(double2 x);
double3 __attribute__((overloadable)) rint(double3 x);
double4 __attribute__((overloadable)) rint(double4 x);
double8 __attribute__((overloadable)) rint(double8 x);
double16 __attribute__((overloadable)) rint(double16 x);
float __attribute__((overloadable)) rootn(float x, int y);
float2 __attribute__((overloadable)) rootn(float2 x, int2 y);
float3 __attribute__((overloadable)) rootn(float3 x, int3 y);
float4 __attribute__((overloadable)) rootn(float4 x, int4 y);
float8 __attribute__((overloadable)) rootn(float8 x, int8 y);
float16 __attribute__((overloadable)) rootn(float16 x, int16 y);
double __attribute__((overloadable)) rootn(double x, int y);
double2 __attribute__((overloadable)) rootn(double2 x, int2 y);
double3 __attribute__((overloadable)) rootn(double3 x, int3 y);
double4 __attribute__((overloadable)) rootn(double4 x, int4 y);
double8 __attribute__((overloadable)) rootn(double8 x, int8 y);
double16 __attribute__((overloadable)) rootn(double16 x, int16 y);
float __attribute__((overloadable)) round(float x);
float2 __attribute__((overloadable)) round(float2 x);
float3 __attribute__((overloadable)) round(float3 x);
float4 __attribute__((overloadable)) round(float4 x);
float8 __attribute__((overloadable)) round(float8 x);
float16 __attribute__((overloadable)) round(float16 x);
double __attribute__((overloadable)) round(double x);
double2 __attribute__((overloadable)) round(double2 x);
double3 __attribute__((overloadable)) round(double3 x);
double4 __attribute__((overloadable)) round(double4 x);
double8 __attribute__((overloadable)) round(double8 x);
double16 __attribute__((overloadable)) round(double16 x);
float __attribute__((overloadable)) rsqrt(float x);
float2 __attribute__((overloadable)) rsqrt(float2 x);
float3 __attribute__((overloadable)) rsqrt(float3 x);
float4 __attribute__((overloadable)) rsqrt(float4 x);
float8 __attribute__((overloadable)) rsqrt(float8 x);
float16 __attribute__((overloadable)) rsqrt(float16 x);
double __attribute__((overloadable)) rsqrt(double x);
double2 __attribute__((overloadable)) rsqrt(double2 x);
double3 __attribute__((overloadable)) rsqrt(double3 x);
double4 __attribute__((overloadable)) rsqrt(double4 x);
double8 __attribute__((overloadable)) rsqrt(double8 x);
double16 __attribute__((overloadable)) rsqrt(double16 x);
float __attribute__((overloadable)) sin(float x);
float2 __attribute__((overloadable)) sin(float2 x);
float3 __attribute__((overloadable)) sin(float3 x);
float4 __attribute__((overloadable)) sin(float4 x);
float8 __attribute__((overloadable)) sin(float8 x);
float16 __attribute__((overloadable)) sin(float16 x);
double __attribute__((overloadable)) sin(double x);
double2 __attribute__((overloadable)) sin(double2 x);
double3 __attribute__((overloadable)) sin(double3 x);
double4 __attribute__((overloadable)) sin(double4 x);
double8 __attribute__((overloadable)) sin(double8 x);
double16 __attribute__((overloadable)) sin(double16 x);
float __attribute__((overloadable)) sincos(float x, __global float* y);
float2 __attribute__((overloadable)) sincos(float2 x, __global float2* y);
float3 __attribute__((overloadable)) sincos(float3 x, __global float3* y);
float4 __attribute__((overloadable)) sincos(float4 x, __global float4* y);
float8 __attribute__((overloadable)) sincos(float8 x, __global float8* y);
float16 __attribute__((overloadable)) sincos(float16 x, __global float16* y);
double __attribute__((overloadable)) sincos(double x, __global double* y);
double2 __attribute__((overloadable)) sincos(double2 x, __global double2* y);
double3 __attribute__((overloadable)) sincos(double3 x, __global double3* y);
double4 __attribute__((overloadable)) sincos(double4 x, __global double4* y);
double8 __attribute__((overloadable)) sincos(double8 x, __global double8* y);
double16 __attribute__((overloadable)) sincos(double16 x, __global double16* y);
float __attribute__((overloadable)) sincos(float x, __local float* y);
float2 __attribute__((overloadable)) sincos(float2 x, __local float2* y);
float3 __attribute__((overloadable)) sincos(float3 x, __local float3* y);
float4 __attribute__((overloadable)) sincos(float4 x, __local float4* y);
float8 __attribute__((overloadable)) sincos(float8 x, __local float8* y);
float16 __attribute__((overloadable)) sincos(float16 x, __local float16* y);
double __attribute__((overloadable)) sincos(double x, __local double* y);
double2 __attribute__((overloadable)) sincos(double2 x, __local double2* y);
double3 __attribute__((overloadable)) sincos(double3 x, __local double3* y);
double4 __attribute__((overloadable)) sincos(double4 x, __local double4* y);
double8 __attribute__((overloadable)) sincos(double8 x, __local double8* y);
double16 __attribute__((overloadable)) sincos(double16 x, __local double16* y);
float __attribute__((overloadable)) sincos(float x, __private float* y);
float2 __attribute__((overloadable)) sincos(float2 x, __private float2* y);
float3 __attribute__((overloadable)) sincos(float3 x, __private float3* y);
float4 __attribute__((overloadable)) sincos(float4 x, __private float4* y);
float8 __attribute__((overloadable)) sincos(float8 x, __private float8* y);
float16 __attribute__((overloadable)) sincos(float16 x, __private float16* y);
double __attribute__((overloadable)) sincos(double x, __private double* y);
double2 __attribute__((overloadable)) sincos(double2 x, __private double2* y);
double3 __attribute__((overloadable)) sincos(double3 x, __private double3* y);
double4 __attribute__((overloadable)) sincos(double4 x, __private double4* y);
double8 __attribute__((overloadable)) sincos(double8 x, __private double8* y);
double16 __attribute__((overloadable)) sincos(double16 x, __private double16* y);
float __attribute__((overloadable)) sinh(float x);
float2 __attribute__((overloadable)) sinh(float2 x);
float3 __attribute__((overloadable)) sinh(float3 x);
float4 __attribute__((overloadable)) sinh(float4 x);
float8 __attribute__((overloadable)) sinh(float8 x);
float16 __attribute__((overloadable)) sinh(float16 x);
double __attribute__((overloadable)) sinh(double x);
double2 __attribute__((overloadable)) sinh(double2 x);
double3 __attribute__((overloadable)) sinh(double3 x);
double4 __attribute__((overloadable)) sinh(double4 x);
double8 __attribute__((overloadable)) sinh(double8 x);
double16 __attribute__((overloadable)) sinh(double16 x);
float __attribute__((overloadable)) sinpi(float x);
float2 __attribute__((overloadable)) sinpi(float2 x);
float3 __attribute__((overloadable)) sinpi(float3 x);
float4 __attribute__((overloadable)) sinpi(float4 x);
float8 __attribute__((overloadable)) sinpi(float8 x);
float16 __attribute__((overloadable)) sinpi(float16 x);
double __attribute__((overloadable)) sinpi(double x);
double2 __attribute__((overloadable)) sinpi(double2 x);
double3 __attribute__((overloadable)) sinpi(double3 x);
double4 __attribute__((overloadable)) sinpi(double4 x);
double8 __attribute__((overloadable)) sinpi(double8 x);
double16 __attribute__((overloadable)) sinpi(double16 x);
float __attribute__((overloadable)) sqrt(float x);
float2 __attribute__((overloadable)) sqrt(float2 x);
float3 __attribute__((overloadable)) sqrt(float3 x);
float4 __attribute__((overloadable)) sqrt(float4 x);
float8 __attribute__((overloadable)) sqrt(float8 x);
float16 __attribute__((overloadable)) sqrt(float16 x);
double __attribute__((overloadable)) sqrt(double x);
double2 __attribute__((overloadable)) sqrt(double2 x);
double3 __attribute__((overloadable)) sqrt(double3 x);
double4 __attribute__((overloadable)) sqrt(double4 x);
double8 __attribute__((overloadable)) sqrt(double8 x);
double16 __attribute__((overloadable)) sqrt(double16 x);
float __attribute__((overloadable)) tan(float x);
float2 __attribute__((overloadable)) tan(float2 x);
float3 __attribute__((overloadable)) tan(float3 x);
float4 __attribute__((overloadable)) tan(float4 x);
float8 __attribute__((overloadable)) tan(float8 x);
float16 __attribute__((overloadable)) tan(float16 x);
double __attribute__((overloadable)) tan(double x);
double2 __attribute__((overloadable)) tan(double2 x);
double3 __attribute__((overloadable)) tan(double3 x);
double4 __attribute__((overloadable)) tan(double4 x);
double8 __attribute__((overloadable)) tan(double8 x);
double16 __attribute__((overloadable)) tan(double16 x);
float __attribute__((overloadable)) tanh(float x);
float2 __attribute__((overloadable)) tanh(float2 x);
float3 __attribute__((overloadable)) tanh(float3 x);
float4 __attribute__((overloadable)) tanh(float4 x);
float8 __attribute__((overloadable)) tanh(float8 x);
float16 __attribute__((overloadable)) tanh(float16 x);
double __attribute__((overloadable)) tanh(double x);
double2 __attribute__((overloadable)) tanh(double2 x);
double3 __attribute__((overloadable)) tanh(double3 x);
double4 __attribute__((overloadable)) tanh(double4 x);
double8 __attribute__((overloadable)) tanh(double8 x);
double16 __attribute__((overloadable)) tanh(double16 x);
float __attribute__((overloadable)) tanpi(float x);
float2 __attribute__((overloadable)) tanpi(float2 x);
float3 __attribute__((overloadable)) tanpi(float3 x);
float4 __attribute__((overloadable)) tanpi(float4 x);
float8 __attribute__((overloadable)) tanpi(float8 x);
float16 __attribute__((overloadable)) tanpi(float16 x);
double __attribute__((overloadable)) tanpi(double x);
double2 __attribute__((overloadable)) tanpi(double2 x);
double3 __attribute__((overloadable)) tanpi(double3 x);
double4 __attribute__((overloadable)) tanpi(double4 x);
double8 __attribute__((overloadable)) tanpi(double8 x);
double16 __attribute__((overloadable)) tanpi(double16 x);
float __attribute__((overloadable)) tgamma(float x);
float2 __attribute__((overloadable)) tgamma(float2 x);
float3 __attribute__((overloadable)) tgamma(float3 x);
float4 __attribute__((overloadable)) tgamma(float4 x);
float8 __attribute__((overloadable)) tgamma(float8 x);
float16 __attribute__((overloadable)) tgamma(float16 x);
double __attribute__((overloadable)) tgamma(double x);
double2 __attribute__((overloadable)) tgamma(double2 x);
double3 __attribute__((overloadable)) tgamma(double3 x);
double4 __attribute__((overloadable)) tgamma(double4 x);
double8 __attribute__((overloadable)) tgamma(double8 x);
double16 __attribute__((overloadable)) tgamma(double16 x);
float __attribute__((overloadable)) trunc(float x);
float2 __attribute__((overloadable)) trunc(float2 x);
float3 __attribute__((overloadable)) trunc(float3 x);
float4 __attribute__((overloadable)) trunc(float4 x);
float8 __attribute__((overloadable)) trunc(float8 x);
float16 __attribute__((overloadable)) trunc(float16 x);
double __attribute__((overloadable)) trunc(double x);
double2 __attribute__((overloadable)) trunc(double2 x);
double3 __attribute__((overloadable)) trunc(double3 x);
double4 __attribute__((overloadable)) trunc(double4 x);
double8 __attribute__((overloadable)) trunc(double8 x);
double16 __attribute__((overloadable)) trunc(double16 x);
float __attribute__((overloadable)) half_cos(float x);
float2 __attribute__((overloadable)) half_cos(float2 x);
float3 __attribute__((overloadable)) half_cos(float3 x);
float4 __attribute__((overloadable)) half_cos(float4 x);
float8 __attribute__((overloadable)) half_cos(float8 x);
float16 __attribute__((overloadable)) half_cos(float16 x);
double __attribute__((overloadable)) half_cos(double x);
double2 __attribute__((overloadable)) half_cos(double2 x);
double3 __attribute__((overloadable)) half_cos(double3 x);
double4 __attribute__((overloadable)) half_cos(double4 x);
double8 __attribute__((overloadable)) half_cos(double8 x);
double16 __attribute__((overloadable)) half_cos(double16 x);
float __attribute__((overloadable)) half_divide(float x, float y);
float2 __attribute__((overloadable)) half_divide(float2 x, float2 y);
float3 __attribute__((overloadable)) half_divide(float3 x, float3 y);
float4 __attribute__((overloadable)) half_divide(float4 x, float4 y);
float8 __attribute__((overloadable)) half_divide(float8 x, float8 y);
float16 __attribute__((overloadable)) half_divide(float16 x, float16 y);
double __attribute__((overloadable)) half_divide(double x, double y);
double2 __attribute__((overloadable)) half_divide(double2 x, double2 y);
double3 __attribute__((overloadable)) half_divide(double3 x, double3 y);
double4 __attribute__((overloadable)) half_divide(double4 x, double4 y);
double8 __attribute__((overloadable)) half_divide(double8 x, double8 y);
double16 __attribute__((overloadable)) half_divide(double16 x, double16 y);
float __attribute__((overloadable)) half_exp(float x);
float2 __attribute__((overloadable)) half_exp(float2 x);
float3 __attribute__((overloadable)) half_exp(float3 x);
float4 __attribute__((overloadable)) half_exp(float4 x);
float8 __attribute__((overloadable)) half_exp(float8 x);
float16 __attribute__((overloadable)) half_exp(float16 x);
double __attribute__((overloadable)) half_exp(double x);
double2 __attribute__((overloadable)) half_exp(double2 x);
double3 __attribute__((overloadable)) half_exp(double3 x);
double4 __attribute__((overloadable)) half_exp(double4 x);
double8 __attribute__((overloadable)) half_exp(double8 x);
double16 __attribute__((overloadable)) half_exp(double16 x);
float __attribute__((overloadable)) half_exp2(float x);
float2 __attribute__((overloadable)) half_exp2(float2 x);
float3 __attribute__((overloadable)) half_exp2(float3 x);
float4 __attribute__((overloadable)) half_exp2(float4 x);
float8 __attribute__((overloadable)) half_exp2(float8 x);
float16 __attribute__((overloadable)) half_exp2(float16 x);
double __attribute__((overloadable)) half_exp2(double x);
double2 __attribute__((overloadable)) half_exp2(double2 x);
double3 __attribute__((overloadable)) half_exp2(double3 x);
double4 __attribute__((overloadable)) half_exp2(double4 x);
double8 __attribute__((overloadable)) half_exp2(double8 x);
double16 __attribute__((overloadable)) half_exp2(double16 x);
float __attribute__((overloadable)) half_exp10(float x);
float2 __attribute__((overloadable)) half_exp10(float2 x);
float3 __attribute__((overloadable)) half_exp10(float3 x);
float4 __attribute__((overloadable)) half_exp10(float4 x);
float8 __attribute__((overloadable)) half_exp10(float8 x);
float16 __attribute__((overloadable)) half_exp10(float16 x);
double __attribute__((overloadable)) half_exp10(double x);
double2 __attribute__((overloadable)) half_exp10(double2 x);
double3 __attribute__((overloadable)) half_exp10(double3 x);
double4 __attribute__((overloadable)) half_exp10(double4 x);
double8 __attribute__((overloadable)) half_exp10(double8 x);
double16 __attribute__((overloadable)) half_exp10(double16 x);
float __attribute__((overloadable)) half_log(float x);
float2 __attribute__((overloadable)) half_log(float2 x);
float3 __attribute__((overloadable)) half_log(float3 x);
float4 __attribute__((overloadable)) half_log(float4 x);
float8 __attribute__((overloadable)) half_log(float8 x);
float16 __attribute__((overloadable)) half_log(float16 x);
double __attribute__((overloadable)) half_log(double x);
double2 __attribute__((overloadable)) half_log(double2 x);
double3 __attribute__((overloadable)) half_log(double3 x);
double4 __attribute__((overloadable)) half_log(double4 x);
double8 __attribute__((overloadable)) half_log(double8 x);
double16 __attribute__((overloadable)) half_log(double16 x);
float __attribute__((overloadable)) half_log2(float x);
float2 __attribute__((overloadable)) half_log2(float2 x);
float3 __attribute__((overloadable)) half_log2(float3 x);
float4 __attribute__((overloadable)) half_log2(float4 x);
float8 __attribute__((overloadable)) half_log2(float8 x);
float16 __attribute__((overloadable)) half_log2(float16 x);
double __attribute__((overloadable)) half_log2(double x);
double2 __attribute__((overloadable)) half_log2(double2 x);
double3 __attribute__((overloadable)) half_log2(double3 x);
double4 __attribute__((overloadable)) half_log2(double4 x);
double8 __attribute__((overloadable)) half_log2(double8 x);
double16 __attribute__((overloadable)) half_log2(double16 x);
float __attribute__((overloadable)) half_log10(float x);
float2 __attribute__((overloadable)) half_log10(float2 x);
float3 __attribute__((overloadable)) half_log10(float3 x);
float4 __attribute__((overloadable)) half_log10(float4 x);
float8 __attribute__((overloadable)) half_log10(float8 x);
float16 __attribute__((overloadable)) half_log10(float16 x);
double __attribute__((overloadable)) half_log10(double x);
double2 __attribute__((overloadable)) half_log10(double2 x);
double3 __attribute__((overloadable)) half_log10(double3 x);
double4 __attribute__((overloadable)) half_log10(double4 x);
double8 __attribute__((overloadable)) half_log10(double8 x);
double16 __attribute__((overloadable)) half_log10(double16 x);
float __attribute__((overloadable)) half_powr(float x, float y);
float2 __attribute__((overloadable)) half_powr(float2 x, float2 y);
float3 __attribute__((overloadable)) half_powr(float3 x, float3 y);
float4 __attribute__((overloadable)) half_powr(float4 x, float4 y);
float8 __attribute__((overloadable)) half_powr(float8 x, float8 y);
float16 __attribute__((overloadable)) half_powr(float16 x, float16 y);
double __attribute__((overloadable)) half_powr(double x, double y);
double2 __attribute__((overloadable)) half_powr(double2 x, double2 y);
double3 __attribute__((overloadable)) half_powr(double3 x, double3 y);
double4 __attribute__((overloadable)) half_powr(double4 x, double4 y);
double8 __attribute__((overloadable)) half_powr(double8 x, double8 y);
double16 __attribute__((overloadable)) half_powr(double16 x, double16 y);
float __attribute__((overloadable)) half_recip(float x);
float2 __attribute__((overloadable)) half_recip(float2 x);
float3 __attribute__((overloadable)) half_recip(float3 x);
float4 __attribute__((overloadable)) half_recip(float4 x);
float8 __attribute__((overloadable)) half_recip(float8 x);
float16 __attribute__((overloadable)) half_recip(float16 x);
double __attribute__((overloadable)) half_recip(double x);
double2 __attribute__((overloadable)) half_recip(double2 x);
double3 __attribute__((overloadable)) half_recip(double3 x);
double4 __attribute__((overloadable)) half_recip(double4 x);
double8 __attribute__((overloadable)) half_recip(double8 x);
double16 __attribute__((overloadable)) half_recip(double16 x);
float __attribute__((overloadable)) half_rsqrt(float x);
float2 __attribute__((overloadable)) half_rsqrt(float2 x);
float3 __attribute__((overloadable)) half_rsqrt(float3 x);
float4 __attribute__((overloadable)) half_rsqrt(float4 x);
float8 __attribute__((overloadable)) half_rsqrt(float8 x);
float16 __attribute__((overloadable)) half_rsqrt(float16 x);
double __attribute__((overloadable)) half_rsqrt(double x);
double2 __attribute__((overloadable)) half_rsqrt(double2 x);
double3 __attribute__((overloadable)) half_rsqrt(double3 x);
double4 __attribute__((overloadable)) half_rsqrt(double4 x);
double8 __attribute__((overloadable)) half_rsqrt(double8 x);
double16 __attribute__((overloadable)) half_rsqrt(double16 x);
float __attribute__((overloadable)) half_sin(float x);
float2 __attribute__((overloadable)) half_sin(float2 x);
float3 __attribute__((overloadable)) half_sin(float3 x);
float4 __attribute__((overloadable)) half_sin(float4 x);
float8 __attribute__((overloadable)) half_sin(float8 x);
float16 __attribute__((overloadable)) half_sin(float16 x);
double __attribute__((overloadable)) half_sin(double x);
double2 __attribute__((overloadable)) half_sin(double2 x);
double3 __attribute__((overloadable)) half_sin(double3 x);
double4 __attribute__((overloadable)) half_sin(double4 x);
double8 __attribute__((overloadable)) half_sin(double8 x);
double16 __attribute__((overloadable)) half_sin(double16 x);
float __attribute__((overloadable)) half_sqrt(float x);
float2 __attribute__((overloadable)) half_sqrt(float2 x);
float3 __attribute__((overloadable)) half_sqrt(float3 x);
float4 __attribute__((overloadable)) half_sqrt(float4 x);
float8 __attribute__((overloadable)) half_sqrt(float8 x);
float16 __attribute__((overloadable)) half_sqrt(float16 x);
double __attribute__((overloadable)) half_sqrt(double x);
double2 __attribute__((overloadable)) half_sqrt(double2 x);
double3 __attribute__((overloadable)) half_sqrt(double3 x);
double4 __attribute__((overloadable)) half_sqrt(double4 x);
double8 __attribute__((overloadable)) half_sqrt(double8 x);
double16 __attribute__((overloadable)) half_sqrt(double16 x);
float __attribute__((overloadable)) half_tan(float x);
float2 __attribute__((overloadable)) half_tan(float2 x);
float3 __attribute__((overloadable)) half_tan(float3 x);
float4 __attribute__((overloadable)) half_tan(float4 x);
float8 __attribute__((overloadable)) half_tan(float8 x);
float16 __attribute__((overloadable)) half_tan(float16 x);
double __attribute__((overloadable)) half_tan(double x);
double2 __attribute__((overloadable)) half_tan(double2 x);
double3 __attribute__((overloadable)) half_tan(double3 x);
double4 __attribute__((overloadable)) half_tan(double4 x);
double8 __attribute__((overloadable)) half_tan(double8 x);
double16 __attribute__((overloadable)) half_tan(double16 x);
float __attribute__((overloadable)) native_cos(float x);
float2 __attribute__((overloadable)) native_cos(float2 x);
float3 __attribute__((overloadable)) native_cos(float3 x);
float4 __attribute__((overloadable)) native_cos(float4 x);
float8 __attribute__((overloadable)) native_cos(float8 x);
float16 __attribute__((overloadable)) native_cos(float16 x);
double __attribute__((overloadable)) native_cos(double x);
double2 __attribute__((overloadable)) native_cos(double2 x);
double3 __attribute__((overloadable)) native_cos(double3 x);
double4 __attribute__((overloadable)) native_cos(double4 x);
double8 __attribute__((overloadable)) native_cos(double8 x);
double16 __attribute__((overloadable)) native_cos(double16 x);
float __attribute__((overloadable)) native_divide(float x, float y);
float2 __attribute__((overloadable)) native_divide(float2 x, float2 y);
float3 __attribute__((overloadable)) native_divide(float3 x, float3 y);
float4 __attribute__((overloadable)) native_divide(float4 x, float4 y);
float8 __attribute__((overloadable)) native_divide(float8 x, float8 y);
float16 __attribute__((overloadable)) native_divide(float16 x, float16 y);
double __attribute__((overloadable)) native_divide(double x, double y);
double2 __attribute__((overloadable)) native_divide(double2 x, double2 y);
double3 __attribute__((overloadable)) native_divide(double3 x, double3 y);
double4 __attribute__((overloadable)) native_divide(double4 x, double4 y);
double8 __attribute__((overloadable)) native_divide(double8 x, double8 y);
double16 __attribute__((overloadable)) native_divide(double16 x, double16 y);
float __attribute__((overloadable)) native_exp(float x);
float2 __attribute__((overloadable)) native_exp(float2 x);
float3 __attribute__((overloadable)) native_exp(float3 x);
float4 __attribute__((overloadable)) native_exp(float4 x);
float8 __attribute__((overloadable)) native_exp(float8 x);
float16 __attribute__((overloadable)) native_exp(float16 x);
double __attribute__((overloadable)) native_exp(double x);
double2 __attribute__((overloadable)) native_exp(double2 x);
double3 __attribute__((overloadable)) native_exp(double3 x);
double4 __attribute__((overloadable)) native_exp(double4 x);
double8 __attribute__((overloadable)) native_exp(double8 x);
double16 __attribute__((overloadable)) native_exp(double16 x);
float __attribute__((overloadable)) native_exp2(float x);
float2 __attribute__((overloadable)) native_exp2(float2 x);
float3 __attribute__((overloadable)) native_exp2(float3 x);
float4 __attribute__((overloadable)) native_exp2(float4 x);
float8 __attribute__((overloadable)) native_exp2(float8 x);
float16 __attribute__((overloadable)) native_exp2(float16 x);
double __attribute__((overloadable)) native_exp2(double x);
double2 __attribute__((overloadable)) native_exp2(double2 x);
double3 __attribute__((overloadable)) native_exp2(double3 x);
double4 __attribute__((overloadable)) native_exp2(double4 x);
double8 __attribute__((overloadable)) native_exp2(double8 x);
double16 __attribute__((overloadable)) native_exp2(double16 x);
float __attribute__((overloadable)) native_exp10(float x);
float2 __attribute__((overloadable)) native_exp10(float2 x);
float3 __attribute__((overloadable)) native_exp10(float3 x);
float4 __attribute__((overloadable)) native_exp10(float4 x);
float8 __attribute__((overloadable)) native_exp10(float8 x);
float16 __attribute__((overloadable)) native_exp10(float16 x);
double __attribute__((overloadable)) native_exp10(double x);
double2 __attribute__((overloadable)) native_exp10(double2 x);
double3 __attribute__((overloadable)) native_exp10(double3 x);
double4 __attribute__((overloadable)) native_exp10(double4 x);
double8 __attribute__((overloadable)) native_exp10(double8 x);
double16 __attribute__((overloadable)) native_exp10(double16 x);
float __attribute__((overloadable)) native_log(float x);
float2 __attribute__((overloadable)) native_log(float2 x);
float3 __attribute__((overloadable)) native_log(float3 x);
float4 __attribute__((overloadable)) native_log(float4 x);
float8 __attribute__((overloadable)) native_log(float8 x);
float16 __attribute__((overloadable)) native_log(float16 x);
double __attribute__((overloadable)) native_log(double x);
double2 __attribute__((overloadable)) native_log(double2 x);
double3 __attribute__((overloadable)) native_log(double3 x);
double4 __attribute__((overloadable)) native_log(double4 x);
double8 __attribute__((overloadable)) native_log(double8 x);
double16 __attribute__((overloadable)) native_log(double16 x);
float __attribute__((overloadable)) native_log2(float x);
float2 __attribute__((overloadable)) native_log2(float2 x);
float3 __attribute__((overloadable)) native_log2(float3 x);
float4 __attribute__((overloadable)) native_log2(float4 x);
float8 __attribute__((overloadable)) native_log2(float8 x);
float16 __attribute__((overloadable)) native_log2(float16 x);
double __attribute__((overloadable)) native_log2(double x);
double2 __attribute__((overloadable)) native_log2(double2 x);
double3 __attribute__((overloadable)) native_log2(double3 x);
double4 __attribute__((overloadable)) native_log2(double4 x);
double8 __attribute__((overloadable)) native_log2(double8 x);
double16 __attribute__((overloadable)) native_log2(double16 x);
float __attribute__((overloadable)) native_log10(float x);
float2 __attribute__((overloadable)) native_log10(float2 x);
float3 __attribute__((overloadable)) native_log10(float3 x);
float4 __attribute__((overloadable)) native_log10(float4 x);
float8 __attribute__((overloadable)) native_log10(float8 x);
float16 __attribute__((overloadable)) native_log10(float16 x);
double __attribute__((overloadable)) native_log10(double x);
double2 __attribute__((overloadable)) native_log10(double2 x);
double3 __attribute__((overloadable)) native_log10(double3 x);
double4 __attribute__((overloadable)) native_log10(double4 x);
double8 __attribute__((overloadable)) native_log10(double8 x);
double16 __attribute__((overloadable)) native_log10(double16 x);
float __attribute__((overloadable)) native_powr(float x, float y);
float2 __attribute__((overloadable)) native_powr(float2 x, float2 y);
float3 __attribute__((overloadable)) native_powr(float3 x, float3 y);
float4 __attribute__((overloadable)) native_powr(float4 x, float4 y);
float8 __attribute__((overloadable)) native_powr(float8 x, float8 y);
float16 __attribute__((overloadable)) native_powr(float16 x, float16 y);
double __attribute__((overloadable)) native_powr(double x, double y);
double2 __attribute__((overloadable)) native_powr(double2 x, double2 y);
double3 __attribute__((overloadable)) native_powr(double3 x, double3 y);
double4 __attribute__((overloadable)) native_powr(double4 x, double4 y);
double8 __attribute__((overloadable)) native_powr(double8 x, double8 y);
double16 __attribute__((overloadable)) native_powr(double16 x, double16 y);
float __attribute__((overloadable)) native_recip(float x);
float2 __attribute__((overloadable)) native_recip(float2 x);
float3 __attribute__((overloadable)) native_recip(float3 x);
float4 __attribute__((overloadable)) native_recip(float4 x);
float8 __attribute__((overloadable)) native_recip(float8 x);
float16 __attribute__((overloadable)) native_recip(float16 x);
double __attribute__((overloadable)) native_recip(double x);
double2 __attribute__((overloadable)) native_recip(double2 x);
double3 __attribute__((overloadable)) native_recip(double3 x);
double4 __attribute__((overloadable)) native_recip(double4 x);
double8 __attribute__((overloadable)) native_recip(double8 x);
double16 __attribute__((overloadable)) native_recip(double16 x);
float __attribute__((overloadable)) native_rsqrt(float x);
float2 __attribute__((overloadable)) native_rsqrt(float2 x);
float3 __attribute__((overloadable)) native_rsqrt(float3 x);
float4 __attribute__((overloadable)) native_rsqrt(float4 x);
float8 __attribute__((overloadable)) native_rsqrt(float8 x);
float16 __attribute__((overloadable)) native_rsqrt(float16 x);
double __attribute__((overloadable)) native_rsqrt(double x);
double2 __attribute__((overloadable)) native_rsqrt(double2 x);
double3 __attribute__((overloadable)) native_rsqrt(double3 x);
double4 __attribute__((overloadable)) native_rsqrt(double4 x);
double8 __attribute__((overloadable)) native_rsqrt(double8 x);
double16 __attribute__((overloadable)) native_rsqrt(double16 x);
float __attribute__((overloadable)) native_sin(float x);
float2 __attribute__((overloadable)) native_sin(float2 x);
float3 __attribute__((overloadable)) native_sin(float3 x);
float4 __attribute__((overloadable)) native_sin(float4 x);
float8 __attribute__((overloadable)) native_sin(float8 x);
float16 __attribute__((overloadable)) native_sin(float16 x);
double __attribute__((overloadable)) native_sin(double x);
double2 __attribute__((overloadable)) native_sin(double2 x);
double3 __attribute__((overloadable)) native_sin(double3 x);
double4 __attribute__((overloadable)) native_sin(double4 x);
double8 __attribute__((overloadable)) native_sin(double8 x);
double16 __attribute__((overloadable)) native_sin(double16 x);
float __attribute__((overloadable)) native_sqrt(float x);
float2 __attribute__((overloadable)) native_sqrt(float2 x);
float3 __attribute__((overloadable)) native_sqrt(float3 x);
float4 __attribute__((overloadable)) native_sqrt(float4 x);
float8 __attribute__((overloadable)) native_sqrt(float8 x);
float16 __attribute__((overloadable)) native_sqrt(float16 x);
double __attribute__((overloadable)) native_sqrt(double x);
double2 __attribute__((overloadable)) native_sqrt(double2 x);
double3 __attribute__((overloadable)) native_sqrt(double3 x);
double4 __attribute__((overloadable)) native_sqrt(double4 x);
double8 __attribute__((overloadable)) native_sqrt(double8 x);
double16 __attribute__((overloadable)) native_sqrt(double16 x);
float __attribute__((overloadable)) native_tan(float x);
float2 __attribute__((overloadable)) native_tan(float2 x);
float3 __attribute__((overloadable)) native_tan(float3 x);
float4 __attribute__((overloadable)) native_tan(float4 x);
float8 __attribute__((overloadable)) native_tan(float8 x);
float16 __attribute__((overloadable)) native_tan(float16 x);
double __attribute__((overloadable)) native_tan(double x);
double2 __attribute__((overloadable)) native_tan(double2 x);
double3 __attribute__((overloadable)) native_tan(double3 x);
double4 __attribute__((overloadable)) native_tan(double4 x);
double8 __attribute__((overloadable)) native_tan(double8 x);
double16 __attribute__((overloadable)) native_tan(double16 x);
#line 99 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"




float4 __attribute__((overloadable)) convert_float4(int4);
float4 __attribute__((overloadable)) convert_float4(uint4);
float4 __attribute__((overloadable)) convert_float4(uchar4);

double4 __attribute__((overloadable)) convert_double4(int4);
double4 __attribute__((overloadable)) convert_double4(uint4);

int4 __attribute__((overloadable)) convert_int4(float4);
int4 __attribute__((overloadable)) convert_int4(uint4);
int4 __attribute__((overloadable)) convert_int4(uchar4);
int8 __attribute__((overloadable)) convert_int8(double8);

uchar4 __attribute__((overloadable)) convert_uchar4(int4);
uchar4 __attribute__((overloadable)) convert_uchar4(float4);
uchar4 __attribute__((overloadable)) convert_uchar4_sat(float4);

uint4 __attribute__((overloadable)) convert_uint4(float4);
uint4 __attribute__((overloadable)) convert_uint4(uchar4);
int __attribute__((overloadable)) clamp(int, int, int);
int2 __attribute__((overloadable)) clamp(int2, int2, int2);
int3 __attribute__((overloadable)) clamp(int3, int3, int3);
int4 __attribute__((overloadable)) clamp(int4, int4, int4);
float3 __attribute__((overloadable)) select(float3, float3, int3);
float4 __attribute__((overloadable)) select(float4, float4, int4);
double4 __attribute__((overloadable)) select(double4, double4, long4);
#line 138 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"
void barrier();
#line 188 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"
bool __axiom0 () { return get_local_size(1) == 1; };
bool __axiom1 () { return get_local_size(2) == 1; };
#line 243 "C:\\prog\\GPUVerifyBenchmarking\\include_cl\\opencl.h"
bool __axiom2 () { return get_num_groups(1) == 1; };
bool __axiom3 () { return get_num_groups(2) == 1; };
#line 95 "kernel.cl"



bool __axiom4 () { return get_local_size(0) == 64; };
bool __axiom5 () { return get_num_groups(0) == 1; };





__attribute__((always_inline)) float
k_sincos(int i, float *cretp)
{
    if (i > 512)
 i -= 1024;

    float x = i * -0x1.921fb6p-8F;
    *cretp = native_cos(x);
    return native_sin(x);
}

__attribute__((always_inline)) float4
k_sincos4(int4 i, float4 *cretp)
{
    i -= (i > 512) & 1024;
    float4 x = convert_float4(i) * -0x1.921fb6p-8F;
    *cretp = native_cos(x);
    return native_sin(x);
}
#line 187 "kernel.cl"
__attribute__((always_inline)) void
kfft_pass1(uint me,
     const __global float *gr, const __global float *gi,
     __local float *lds)
{
    const __global float4 *gp;
    __local float *lp;
#line 209 "kernel.cl"
    float4 zr0;
    float4 zr1;
    float4 zr2;
    float4 zr3;

    float4 zi0;
    float4 zi1;
    float4 zi2;
    float4 zi3;

    do { float4 ar0 = zr0 + zr2; float4 ar2 = zr1 + zr3; float4 br0 = ar0 + ar2; float4 br1 = zr0 - zr2; float4 br2 = ar0 - ar2; float4 br3 = zr1 - zr3; float4 ai0 = zi0 + zi2; float4 ai2 = zi1 + zi3; float4 bi0 = ai0 + ai2; float4 bi1 = zi0 - zi2; float4 bi2 = ai0 - ai2; float4 bi3 = zi1 - zi3; zr0 = br0; zi0 = bi0; zr1 = br1 + bi3; zi1 = bi1 - br3; zr3 = br1 - bi3; zi3 = br3 + bi1; zr2 = br2; zi2 = bi2; } while (0);

    int4 tbase = (int)(me << 2) + (int4)(0, 1, 2, 3);
    do { float4 c1_1; float4 s1 = k_sincos4(tbase * 1, &c1_1); do { float4 __r = c1_1 * zr1 - s1 * zi1; zi1 = c1_1 * zi1 + s1 * zr1; zr1 = __r; } while (0); float4 c2_1; float4 s2 = k_sincos4(tbase * 2, &c2_1); do { float4 __r = c2_1 * zr2 - s2 * zi2; zi2 = c2_1 * zi2 + s2 * zr2; zr2 = __r; } while (0); float4 c3_1; float4 s3 = k_sincos4(tbase * 3, &c3_1); do { float4 __r = c3_1 * zr3 - s3 * zi3; zi3 = c3_1 * zi3 + s3 * zr3; zr3 = __r; } while (0); } while (0);



    lp = lds + ((me << 2) + (me >> 3));

    lp[0] = zr0.x;
    lp[1] = zr0.y;
    lp[2] = zr0.z;
    lp[3] = zr0.w;
    lp += 66*4;

    lp[0] = zr1.x;
    lp[1] = zr1.y;
    lp[2] = zr1.z;
    lp[3] = zr1.w;
    lp += 66*4;

    lp[0] = zr2.x;
    lp[1] = zr2.y;
    lp[2] = zr2.z;
    lp[3] = zr2.w;
    lp += 66*4;

    lp[0] = zr3.x;
    lp[1] = zr3.y;
    lp[2] = zr3.z;
    lp[3] = zr3.w;
    lp += 66*4;


    lp[0] = zi0.x;
    lp[1] = zi0.y;
    lp[2] = zi0.z;
    lp[3] = zi0.w;
    lp += 66*4;

    lp[0] = zi1.x;
    lp[1] = zi1.y;
    lp[2] = zi1.z;
    lp[3] = zi1.w;
    lp += 66*4;

    lp[0] = zi2.x;
    lp[1] = zi2.y;
    lp[2] = zi2.z;
    lp[3] = zi2.w;
    lp += 66*4;

    lp[0] = zi3.x;
    lp[1] = zi3.y;
    lp[2] = zi3.z;
    lp[3] = zi3.w;

    barrier();
}


__attribute__((always_inline)) void
kfft_pass2(uint me, __local float *lds)
{
    __local float *lp;


    lp = lds + (me + (me >> 5));

    float4 zr0, zr1, zr2, zr3;

    zr0.x = lp[0*66];
    zr1.x = lp[1*66];
    zr2.x = lp[2*66];
    zr3.x = lp[3*66];
    lp += 66*4;

    zr0.y = lp[0*66];
    zr1.y = lp[1*66];
    zr2.y = lp[2*66];
    zr3.y = lp[3*66];
    lp += 66*4;

    zr0.z = lp[0*66];
    zr1.z = lp[1*66];
    zr2.z = lp[2*66];
    zr3.z = lp[3*66];
    lp += 66*4;

    zr0.w = lp[0*66];
    zr1.w = lp[1*66];
    zr2.w = lp[2*66];
    zr3.w = lp[3*66];
    lp += 66*4;

    float4 zi0, zi1, zi2, zi3;

    zi0.x = lp[0*66];
    zi1.x = lp[1*66];
    zi2.x = lp[2*66];
    zi3.x = lp[3*66];
    lp += 66*4;

    zi0.y = lp[0*66];
    zi1.y = lp[1*66];
    zi2.y = lp[2*66];
    zi3.y = lp[3*66];
    lp += 66*4;

    zi0.z = lp[0*66];
    zi1.z = lp[1*66];
    zi2.z = lp[2*66];
    zi3.z = lp[3*66];
    lp += 66*4;

    zi0.w = lp[0*66];
    zi1.w = lp[1*66];
    zi2.w = lp[2*66];
    zi3.w = lp[3*66];


    do { float4 ar0 = zr0 + zr2; float4 ar2 = zr1 + zr3; float4 br0 = ar0 + ar2; float4 br1 = zr0 - zr2; float4 br2 = ar0 - ar2; float4 br3 = zr1 - zr3; float4 ai0 = zi0 + zi2; float4 ai2 = zi1 + zi3; float4 bi0 = ai0 + ai2; float4 bi1 = zi0 - zi2; float4 bi2 = ai0 - ai2; float4 bi3 = zi1 - zi3; zr0 = br0; zi0 = bi0; zr1 = br1 + bi3; zi1 = bi1 - br3; zr3 = br1 - bi3; zi3 = br3 + bi1; zr2 = br2; zi2 = bi2; } while (0);

    int tbase = (int)(me << 2);
    do { float c1_2; float s1 = k_sincos(tbase * 1, &c1_2); do { float4 __r = c1_2 * zr1 - s1 * zi1; zi1 = c1_2 * zi1 + s1 * zr1; zr1 = __r; } while (0); float c2_2; float s2 = k_sincos(tbase * 2, &c2_2); do { float4 __r = c2_2 * zr2 - s2 * zi2; zi2 = c2_2 * zi2 + s2 * zr2; zr2 = __r; } while (0); float c3_2; float s3 = k_sincos(tbase * 3, &c3_2); do { float4 __r = c3_2 * zr3 - s3 * zi3; zi3 = c3_2 * zi3 + s3 * zr3; zr3 = __r; } while (0); } while (0);

    barrier();


    lp = lds + ((me << 2) + (me >> 3));

    lp[0] = zr0.x;
    lp[1] = zr1.x;
    lp[2] = zr2.x;
    lp[3] = zr3.x;
    lp += 66*4;

    lp[0] = zr0.y;
    lp[1] = zr1.y;
    lp[2] = zr2.y;
    lp[3] = zr3.y;
    lp += 66*4;

    lp[0] = zr0.z;
    lp[1] = zr1.z;
    lp[2] = zr2.z;
    lp[3] = zr3.z;
    lp += 66*4;

    lp[0] = zr0.w;
    lp[1] = zr1.w;
    lp[2] = zr2.w;
    lp[3] = zr3.w;
    lp += 66*4;


    lp[0] = zi0.x;
    lp[1] = zi1.x;
    lp[2] = zi2.x;
    lp[3] = zi3.x;
    lp += 66*4;

    lp[0] = zi0.y;
    lp[1] = zi1.y;
    lp[2] = zi2.y;
    lp[3] = zi3.y;
    lp += 66*4;

    lp[0] = zi0.z;
    lp[1] = zi1.z;
    lp[2] = zi2.z;
    lp[3] = zi3.z;
    lp += 66*4;

    lp[0] = zi0.w;
    lp[1] = zi1.w;
    lp[2] = zi2.w;
    lp[3] = zi3.w;

    barrier();
}


__attribute__((always_inline)) void
kfft_pass3(uint me, __local float *lds)
{
    __local float *lp;


    lp = lds + (me + (me >> 5));

    float4 zr0, zr1, zr2, zr3;

    zr0.x = lp[0*66];
    zr1.x = lp[1*66];
    zr2.x = lp[2*66];
    zr3.x = lp[3*66];
    lp += 66*4;

    zr0.y = lp[0*66];
    zr1.y = lp[1*66];
    zr2.y = lp[2*66];
    zr3.y = lp[3*66];
    lp += 66*4;

    zr0.z = lp[0*66];
    zr1.z = lp[1*66];
    zr2.z = lp[2*66];
    zr3.z = lp[3*66];
    lp += 66*4;

    zr0.w = lp[0*66];
    zr1.w = lp[1*66];
    zr2.w = lp[2*66];
    zr3.w = lp[3*66];
    lp += 66*4;

    float4 zi0, zi1, zi2, zi3;

    zi0.x = lp[0*66];
    zi1.x = lp[1*66];
    zi2.x = lp[2*66];
    zi3.x = lp[3*66];
    lp += 66*4;

    zi0.y = lp[0*66];
    zi1.y = lp[1*66];
    zi2.y = lp[2*66];
    zi3.y = lp[3*66];
    lp += 66*4;

    zi0.z = lp[0*66];
    zi1.z = lp[1*66];
    zi2.z = lp[2*66];
    zi3.z = lp[3*66];
    lp += 66*4;

    zi0.w = lp[0*66];
    zi1.w = lp[1*66];
    zi2.w = lp[2*66];
    zi3.w = lp[3*66];


    do { float4 ar0 = zr0 + zr2; float4 ar2 = zr1 + zr3; float4 br0 = ar0 + ar2; float4 br1 = zr0 - zr2; float4 br2 = ar0 - ar2; float4 br3 = zr1 - zr3; float4 ai0 = zi0 + zi2; float4 ai2 = zi1 + zi3; float4 bi0 = ai0 + ai2; float4 bi1 = zi0 - zi2; float4 bi2 = ai0 - ai2; float4 bi3 = zi1 - zi3; zr0 = br0; zi0 = bi0; zr1 = br1 + bi3; zi1 = bi1 - br3; zr3 = br1 - bi3; zi3 = br3 + bi1; zr2 = br2; zi2 = bi2; } while (0);

    int tbase = (int)((me >> 2) << 4);
    do { float c1_3; float s1 = k_sincos(tbase * 1, &c1_3); do { float4 __r = c1_3 * zr1 - s1 * zi1; zi1 = c1_3 * zi1 + s1 * zr1; zr1 = __r; } while (0); float c2_3; float s2 = k_sincos(tbase * 2, &c2_3); do { float4 __r = c2_3 * zr2 - s2 * zi2; zi2 = c2_3 * zi2 + s2 * zr2; zr2 = __r; } while (0); float c3_3; float s3 = k_sincos(tbase * 3, &c3_3); do { float4 __r = c3_3 * zr3 - s3 * zi3; zi3 = c3_3 * zi3 + s3 * zr3; zr3 = __r; } while (0); } while (0);

    barrier();


    lp = lds + me;

    lp[0*66] = zr0.x;
    lp[1*66] = zr0.y;
    lp[2*66] = zr0.z;
    lp[3*66] = zr0.w;
    lp += 66*4;

    lp[0*66] = zr1.x;
    lp[1*66] = zr1.y;
    lp[2*66] = zr1.z;
    lp[3*66] = zr1.w;
    lp += 66*4;

    lp[0*66] = zr2.x;
    lp[1*66] = zr2.y;
    lp[2*66] = zr2.z;
    lp[3*66] = zr2.w;
    lp += 66*4;

    lp[0*66] = zr3.x;
    lp[1*66] = zr3.y;
    lp[2*66] = zr3.z;
    lp[3*66] = zr3.w;
    lp += 66*4;


    lp[0*66] = zi0.x;
    lp[1*66] = zi0.y;
    lp[2*66] = zi0.z;
    lp[3*66] = zi0.w;
    lp += 66*4;

    lp[0*66] = zi1.x;
    lp[1*66] = zi1.y;
    lp[2*66] = zi1.z;
    lp[3*66] = zi1.w;
    lp += 66*4;

    lp[0*66] = zi2.x;
    lp[1*66] = zi2.y;
    lp[2*66] = zi2.z;
    lp[3*66] = zi2.w;
    lp += 66*4;

    lp[0*66] = zi3.x;
    lp[1*66] = zi3.y;
    lp[2*66] = zi3.z;
    lp[3*66] = zi3.w;

    barrier();
}


__attribute__((always_inline)) void
kfft_pass4(uint me, __local float *lds)
{
    __local float *lp;


    lp = lds + ((me & 0x3) + ((me >> 2) & 0x3)*(66*4) + ((me >> 4) << 2));

    float4 zr0, zr1, zr2, zr3;

    zr0.x = lp[0*66];
    zr0.y = lp[1*66];
    zr0.z = lp[2*66];
    zr0.w = lp[3*66];
    lp += 16;

    zr1.x = lp[0*66];
    zr1.y = lp[1*66];
    zr1.z = lp[2*66];
    zr1.w = lp[3*66];
    lp += 16;

    zr2.x = lp[0*66];
    zr2.y = lp[1*66];
    zr2.z = lp[2*66];
    zr2.w = lp[3*66];
    lp += 16;

    zr3.x = lp[0*66];
    zr3.y = lp[1*66];
    zr3.z = lp[2*66];
    zr3.w = lp[3*66];
    lp += 66*4*4 - 3*16;

    float4 zi0, zi1, zi2, zi3;

    zi0.x = lp[0*66];
    zi0.y = lp[1*66];
    zi0.z = lp[2*66];
    zi0.w = lp[3*66];
    lp += 16;

    zi1.x = lp[0*66];
    zi1.y = lp[1*66];
    zi1.z = lp[2*66];
    zi1.w = lp[3*66];
    lp += 16;

    zi2.x = lp[0*66];
    zi2.y = lp[1*66];
    zi2.z = lp[2*66];
    zi2.w = lp[3*66];
    lp += 16;

    zi3.x = lp[0*66];
    zi3.y = lp[1*66];
    zi3.z = lp[2*66];
    zi3.w = lp[3*66];


    do { float4 ar0 = zr0 + zr2; float4 ar2 = zr1 + zr3; float4 br0 = ar0 + ar2; float4 br1 = zr0 - zr2; float4 br2 = ar0 - ar2; float4 br3 = zr1 - zr3; float4 ai0 = zi0 + zi2; float4 ai2 = zi1 + zi3; float4 bi0 = ai0 + ai2; float4 bi1 = zi0 - zi2; float4 bi2 = ai0 - ai2; float4 bi3 = zi1 - zi3; zr0 = br0; zi0 = bi0; zr1 = br1 + bi3; zi1 = bi1 - br3; zr3 = br1 - bi3; zi3 = br3 + bi1; zr2 = br2; zi2 = bi2; } while (0);

    int tbase = (int)((me >> 4) << 6);
    do { float c1_4; float s1 = k_sincos(tbase * 1, &c1_4); do { float4 __r = c1_4 * zr1 - s1 * zi1; zi1 = c1_4 * zi1 + s1 * zr1; zr1 = __r; } while (0); float c2_4; float s2 = k_sincos(tbase * 2, &c2_4); do { float4 __r = c2_4 * zr2 - s2 * zi2; zi2 = c2_4 * zi2 + s2 * zr2; zr2 = __r; } while (0); float c3_4; float s3 = k_sincos(tbase * 3, &c3_4); do { float4 __r = c3_4 * zr3 - s3 * zi3; zi3 = c3_4 * zi3 + s3 * zr3; zr3 = __r; } while (0); } while (0);

    barrier();


    lp = lds + me;

    lp[0*68] = zr0.x;
    lp[1*68] = zr0.y;
    lp[2*68] = zr0.z;
    lp[3*68] = zr0.w;
    lp += 68*4;

    lp[0*68] = zr1.x;
    lp[1*68] = zr1.y;
    lp[2*68] = zr1.z;
    lp[3*68] = zr1.w;
    lp += 68*4;

    lp[0*68] = zr2.x;
    lp[1*68] = zr2.y;
    lp[2*68] = zr2.z;
    lp[3*68] = zr2.w;
    lp += 68*4;

    lp[0*68] = zr3.x;
    lp[1*68] = zr3.y;
    lp[2*68] = zr3.z;
    lp[3*68] = zr3.w;
    lp += 68*4;


    lp[0*68] = zi0.x;
    lp[1*68] = zi0.y;
    lp[2*68] = zi0.z;
    lp[3*68] = zi0.w;
    lp += 68*4;

    lp[0*68] = zi1.x;
    lp[1*68] = zi1.y;
    lp[2*68] = zi1.z;
    lp[3*68] = zi1.w;
    lp += 68*4;

    lp[0*68] = zi2.x;
    lp[1*68] = zi2.y;
    lp[2*68] = zi2.z;
    lp[3*68] = zi2.w;
    lp += 68*4;

    lp[0*68] = zi3.x;
    lp[1*68] = zi3.y;
    lp[2*68] = zi3.z;
    lp[3*68] = zi3.w;

    barrier();
}


__attribute__((always_inline)) void
kfft_pass5(uint me,
    const __local float *lds,
    __global float *gr, __global float *gi)
{
    const __local float *lp;


    lp = lds + ((me & 0xf) + (me >> 4)*(68*4));

    float4 zr0, zr1, zr2, zr3;

    zr0.x = lp[0*68];
    zr0.y = lp[1*68];
    zr0.z = lp[2*68];
    zr0.w = lp[3*68];
    lp += 16;

    zr1.x = lp[0*68];
    zr1.y = lp[1*68];
    zr1.z = lp[2*68];
    zr1.w = lp[3*68];
    lp += 16;

    zr2.x = lp[0*68];
    zr2.y = lp[1*68];
    zr2.z = lp[2*68];
    zr2.w = lp[3*68];
    lp += 16;

    zr3.x = lp[0*68];
    zr3.y = lp[1*68];
    zr3.z = lp[2*68];
    zr3.w = lp[3*68];

    lp += 68*4*4 - 3*16;

    float4 zi0, zi1, zi2, zi3;

    zi0.x = lp[0*68];
    zi0.y = lp[1*68];
    zi0.z = lp[2*68];
    zi0.w = lp[3*68];
    lp += 16;

    zi1.x = lp[0*68];
    zi1.y = lp[1*68];
    zi1.z = lp[2*68];
    zi1.w = lp[3*68];
    lp += 16;

    zi2.x = lp[0*68];
    zi2.y = lp[1*68];
    zi2.z = lp[2*68];
    zi2.w = lp[3*68];
    lp += 16;

    zi3.x = lp[0*68];
    zi3.y = lp[1*68];
    zi3.z = lp[2*68];
    zi3.w = lp[3*68];


    do { float4 ar0 = zr0 + zr2; float4 ar2 = zr1 + zr3; float4 br0 = ar0 + ar2; float4 br1 = zr0 - zr2; float4 br2 = ar0 - ar2; float4 br3 = zr1 - zr3; float4 ai0 = zi0 + zi2; float4 ai2 = zi1 + zi3; float4 bi0 = ai0 + ai2; float4 bi1 = zi0 - zi2; float4 bi2 = ai0 - ai2; float4 bi3 = zi1 - zi3; zr0 = br0; zi0 = bi0; zr1 = br1 + bi3; zi1 = bi1 - br3; zr3 = br1 - bi3; zi3 = br3 + bi1; zr2 = br2; zi2 = bi2; } while (0);

#ifdef PERFECT_FRONT_END
    __global float4 *gp = (__global float4 *)(gr + (me << 2));
    gp[0*64] = zr0;
    gp[1*64] = zr1;
    gp[2*64] = zr2;
    gp[3*64] = zr3;

    gp = (__global float4 *)(gi + (me << 2));
    gp[0*64] = zi0;
    gp[1*64] = zi1;
    gp[2*64] = zi2;
    gp[3*64] = zi3;
#else
    __global float *gp = (gr + (me << 2));
    gp[0*64 + 0] = zr0.x;
    gp[0*64 + 1] = zr0.y;
    gp[0*64 + 2] = zr0.z;
    gp[0*64 + 3] = zr0.w;

    gp[1*64 + 0] = zr1.x;
    gp[1*64 + 1] = zr1.y;
    gp[1*64 + 2] = zr1.z;
    gp[1*64 + 3] = zr1.w;

    gp[2*64 + 0] = zr2.x;
    gp[2*64 + 1] = zr2.y;
    gp[2*64 + 2] = zr2.z;
    gp[2*64 + 3] = zr2.w;

    gp[3*64 + 0] = zr3.x;
    gp[3*64 + 1] = zr3.y;
    gp[3*64 + 2] = zr3.z;
    gp[3*64 + 3] = zr3.w;

    gp = (gi + (me << 2));
    gp[0*64 + 0] = zi0.x;
    gp[0*64 + 1] = zi0.y;
    gp[0*64 + 2] = zi0.z;
    gp[0*64 + 3] = zi0.w;

    gp[1*64 + 0] = zi1.x;
    gp[1*64 + 1] = zi1.y;
    gp[1*64 + 2] = zi1.z;
    gp[1*64 + 3] = zi1.w;

    gp[2*64 + 0] = zi2.x;
    gp[2*64 + 1] = zi2.y;
    gp[2*64 + 2] = zi2.z;
    gp[2*64 + 3] = zi2.w;

    gp[3*64 + 0] = zi3.x;
    gp[3*64 + 1] = zi3.y;
    gp[3*64 + 2] = zi3.z;
    gp[3*64 + 3] = zi3.w;
#endif

}
#line 735 "kernel.cl"
__kernel void
kfft(__global float *greal, __global float *gimag)
{

    __local float lds[68*4*4*2];

    __global float *gr;
    __global float *gi;
    uint gid = get_global_id(0);
    uint me = gid & 0x3fU;
    uint dg = (gid >> 6) * (1024 +0);

    gr = greal + dg;
    gi = gimag + dg;

    kfft_pass1(me, gr, gi, lds);
    kfft_pass2(me, lds);
    kfft_pass3(me, lds);
    kfft_pass4(me, lds);
    kfft_pass5(me, lds, gr, gi);
}
