tests/tests/renderscript/src/android/renderscript/cts/generated/TestConvert.rs

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Don't edit this file!  It is auto-generated by frameworks/rs/api/generate.sh.

#pragma version(1)
#pragma rs java_package_name(android.renderscript.cts)


float2 __attribute__((kernel)) testConvertFloat2Float2Float2(float2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Float3Float3(float3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Float4Float4(float4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Char2Float2(char2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Char3Float3(char3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Char4Float4(char4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Uchar2Float2(uchar2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Uchar3Float3(uchar3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Uchar4Float4(uchar4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Short2Float2(short2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Short3Float3(short3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Short4Float4(short4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Ushort2Float2(ushort2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Ushort3Float3(ushort3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Ushort4Float4(ushort4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Int2Float2(int2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Int3Float3(int3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Int4Float4(int4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Uint2Float2(uint2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Uint3Float3(uint3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Uint4Float4(uint4 inV) {
    return convert_float4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Float2Char2(float2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Float3Char3(float3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Float4Char4(float4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Char2Char2(char2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Char3Char3(char3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Char4Char4(char4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Uchar2Char2(uchar2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Uchar3Char3(uchar3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Uchar4Char4(uchar4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Short2Char2(short2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Short3Char3(short3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Short4Char4(short4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Ushort2Char2(ushort2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Ushort3Char3(ushort3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Ushort4Char4(ushort4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Int2Char2(int2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Int3Char3(int3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Int4Char4(int4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Uint2Char2(uint2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Uint3Char3(uint3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Uint4Char4(uint4 inV) {
    return convert_char4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Float2Uchar2(float2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Float3Uchar3(float3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Float4Uchar4(float4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Char2Uchar2(char2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Char3Uchar3(char3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Char4Uchar4(char4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Uchar2Uchar2(uchar2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Uchar3Uchar3(uchar3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Uchar4Uchar4(uchar4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Short2Uchar2(short2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Short3Uchar3(short3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Short4Uchar4(short4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Ushort2Uchar2(ushort2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Ushort3Uchar3(ushort3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Ushort4Uchar4(ushort4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Int2Uchar2(int2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Int3Uchar3(int3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Int4Uchar4(int4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Uint2Uchar2(uint2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Uint3Uchar3(uint3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Uint4Uchar4(uint4 inV) {
    return convert_uchar4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Float2Short2(float2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Float3Short3(float3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Float4Short4(float4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Char2Short2(char2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Char3Short3(char3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Char4Short4(char4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Uchar2Short2(uchar2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Uchar3Short3(uchar3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Uchar4Short4(uchar4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Short2Short2(short2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Short3Short3(short3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Short4Short4(short4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Ushort2Short2(ushort2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Ushort3Short3(ushort3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Ushort4Short4(ushort4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Int2Short2(int2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Int3Short3(int3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Int4Short4(int4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Uint2Short2(uint2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Uint3Short3(uint3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Uint4Short4(uint4 inV) {
    return convert_short4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Float2Ushort2(float2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Float3Ushort3(float3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Float4Ushort4(float4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Char2Ushort2(char2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Char3Ushort3(char3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Char4Ushort4(char4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Uchar2Ushort2(uchar2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Uchar3Ushort3(uchar3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Uchar4Ushort4(uchar4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Short2Ushort2(short2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Short3Ushort3(short3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Short4Ushort4(short4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Ushort2Ushort2(ushort2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Ushort3Ushort3(ushort3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Ushort4Ushort4(ushort4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Int2Ushort2(int2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Int3Ushort3(int3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Int4Ushort4(int4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Uint2Ushort2(uint2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Uint3Ushort3(uint3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Uint4Ushort4(uint4 inV) {
    return convert_ushort4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Float2Int2(float2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Float3Int3(float3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Float4Int4(float4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Char2Int2(char2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Char3Int3(char3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Char4Int4(char4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Uchar2Int2(uchar2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Uchar3Int3(uchar3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Uchar4Int4(uchar4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Short2Int2(short2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Short3Int3(short3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Short4Int4(short4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Ushort2Int2(ushort2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Ushort3Int3(ushort3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Ushort4Int4(ushort4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Int2Int2(int2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Int3Int3(int3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Int4Int4(int4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Uint2Int2(uint2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Uint3Int3(uint3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Uint4Int4(uint4 inV) {
    return convert_int4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Float2Uint2(float2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Float3Uint3(float3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Float4Uint4(float4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Char2Uint2(char2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Char3Uint3(char3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Char4Uint4(char4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Uchar2Uint2(uchar2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Uchar3Uint3(uchar3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Uchar4Uint4(uchar4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Short2Uint2(short2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Short3Uint3(short3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Short4Uint4(short4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Ushort2Uint2(ushort2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Ushort3Uint3(ushort3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Ushort4Uint4(ushort4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Int2Uint2(int2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Int3Uint3(int3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Int4Uint4(int4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Uint2Uint2(uint2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Uint3Uint3(uint3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Uint4Uint4(uint4 inV) {
    return convert_uint4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Double2Double2(double2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Double3Double3(double3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Double4Double4(double4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Long2Double2(long2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Long3Double3(long3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Long4Double4(long4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Ulong2Double2(ulong2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Ulong3Double3(ulong3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Ulong4Double4(ulong4 inV) {
    return convert_double4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Double2Long2(double2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Double3Long3(double3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Double4Long4(double4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Long2Long2(long2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Long3Long3(long3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Long4Long4(long4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Ulong2Long2(ulong2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Ulong3Long3(ulong3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Ulong4Long4(ulong4 inV) {
    return convert_long4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Double2Ulong2(double2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Double3Ulong3(double3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Double4Ulong4(double4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Long2Ulong2(long2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Long3Ulong3(long3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Long4Ulong4(long4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Ulong2Ulong2(ulong2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Ulong3Ulong3(ulong3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Ulong4Ulong4(ulong4 inV) {
    return convert_ulong4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Double2Float2(double2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Double3Float3(double3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Double4Float4(double4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Long2Float2(long2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Long3Float3(long3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Long4Float4(long4 inV) {
    return convert_float4(inV);
}

float2 __attribute__((kernel)) testConvertFloat2Ulong2Float2(ulong2 inV) {
    return convert_float2(inV);
}

float3 __attribute__((kernel)) testConvertFloat3Ulong3Float3(ulong3 inV) {
    return convert_float3(inV);
}

float4 __attribute__((kernel)) testConvertFloat4Ulong4Float4(ulong4 inV) {
    return convert_float4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Double2Char2(double2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Double3Char3(double3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Double4Char4(double4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Long2Char2(long2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Long3Char3(long3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Long4Char4(long4 inV) {
    return convert_char4(inV);
}

char2 __attribute__((kernel)) testConvertChar2Ulong2Char2(ulong2 inV) {
    return convert_char2(inV);
}

char3 __attribute__((kernel)) testConvertChar3Ulong3Char3(ulong3 inV) {
    return convert_char3(inV);
}

char4 __attribute__((kernel)) testConvertChar4Ulong4Char4(ulong4 inV) {
    return convert_char4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Double2Uchar2(double2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Double3Uchar3(double3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Double4Uchar4(double4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Long2Uchar2(long2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Long3Uchar3(long3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Long4Uchar4(long4 inV) {
    return convert_uchar4(inV);
}

uchar2 __attribute__((kernel)) testConvertUchar2Ulong2Uchar2(ulong2 inV) {
    return convert_uchar2(inV);
}

uchar3 __attribute__((kernel)) testConvertUchar3Ulong3Uchar3(ulong3 inV) {
    return convert_uchar3(inV);
}

uchar4 __attribute__((kernel)) testConvertUchar4Ulong4Uchar4(ulong4 inV) {
    return convert_uchar4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Double2Short2(double2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Double3Short3(double3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Double4Short4(double4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Long2Short2(long2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Long3Short3(long3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Long4Short4(long4 inV) {
    return convert_short4(inV);
}

short2 __attribute__((kernel)) testConvertShort2Ulong2Short2(ulong2 inV) {
    return convert_short2(inV);
}

short3 __attribute__((kernel)) testConvertShort3Ulong3Short3(ulong3 inV) {
    return convert_short3(inV);
}

short4 __attribute__((kernel)) testConvertShort4Ulong4Short4(ulong4 inV) {
    return convert_short4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Double2Ushort2(double2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Double3Ushort3(double3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Double4Ushort4(double4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Long2Ushort2(long2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Long3Ushort3(long3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Long4Ushort4(long4 inV) {
    return convert_ushort4(inV);
}

ushort2 __attribute__((kernel)) testConvertUshort2Ulong2Ushort2(ulong2 inV) {
    return convert_ushort2(inV);
}

ushort3 __attribute__((kernel)) testConvertUshort3Ulong3Ushort3(ulong3 inV) {
    return convert_ushort3(inV);
}

ushort4 __attribute__((kernel)) testConvertUshort4Ulong4Ushort4(ulong4 inV) {
    return convert_ushort4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Double2Int2(double2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Double3Int3(double3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Double4Int4(double4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Long2Int2(long2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Long3Int3(long3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Long4Int4(long4 inV) {
    return convert_int4(inV);
}

int2 __attribute__((kernel)) testConvertInt2Ulong2Int2(ulong2 inV) {
    return convert_int2(inV);
}

int3 __attribute__((kernel)) testConvertInt3Ulong3Int3(ulong3 inV) {
    return convert_int3(inV);
}

int4 __attribute__((kernel)) testConvertInt4Ulong4Int4(ulong4 inV) {
    return convert_int4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Double2Uint2(double2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Double3Uint3(double3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Double4Uint4(double4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Long2Uint2(long2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Long3Uint3(long3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Long4Uint4(long4 inV) {
    return convert_uint4(inV);
}

uint2 __attribute__((kernel)) testConvertUint2Ulong2Uint2(ulong2 inV) {
    return convert_uint2(inV);
}

uint3 __attribute__((kernel)) testConvertUint3Ulong3Uint3(ulong3 inV) {
    return convert_uint3(inV);
}

uint4 __attribute__((kernel)) testConvertUint4Ulong4Uint4(ulong4 inV) {
    return convert_uint4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Float2Double2(float2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Float3Double3(float3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Float4Double4(float4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Char2Double2(char2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Char3Double3(char3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Char4Double4(char4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Uchar2Double2(uchar2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Uchar3Double3(uchar3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Uchar4Double4(uchar4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Short2Double2(short2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Short3Double3(short3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Short4Double4(short4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Ushort2Double2(ushort2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Ushort3Double3(ushort3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Ushort4Double4(ushort4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Int2Double2(int2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Int3Double3(int3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Int4Double4(int4 inV) {
    return convert_double4(inV);
}

double2 __attribute__((kernel)) testConvertDouble2Uint2Double2(uint2 inV) {
    return convert_double2(inV);
}

double3 __attribute__((kernel)) testConvertDouble3Uint3Double3(uint3 inV) {
    return convert_double3(inV);
}

double4 __attribute__((kernel)) testConvertDouble4Uint4Double4(uint4 inV) {
    return convert_double4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Float2Long2(float2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Float3Long3(float3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Float4Long4(float4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Char2Long2(char2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Char3Long3(char3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Char4Long4(char4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Uchar2Long2(uchar2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Uchar3Long3(uchar3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Uchar4Long4(uchar4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Short2Long2(short2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Short3Long3(short3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Short4Long4(short4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Ushort2Long2(ushort2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Ushort3Long3(ushort3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Ushort4Long4(ushort4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Int2Long2(int2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Int3Long3(int3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Int4Long4(int4 inV) {
    return convert_long4(inV);
}

long2 __attribute__((kernel)) testConvertLong2Uint2Long2(uint2 inV) {
    return convert_long2(inV);
}

long3 __attribute__((kernel)) testConvertLong3Uint3Long3(uint3 inV) {
    return convert_long3(inV);
}

long4 __attribute__((kernel)) testConvertLong4Uint4Long4(uint4 inV) {
    return convert_long4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Float2Ulong2(float2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Float3Ulong3(float3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Float4Ulong4(float4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Char2Ulong2(char2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Char3Ulong3(char3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Char4Ulong4(char4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Uchar2Ulong2(uchar2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Uchar3Ulong3(uchar3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Uchar4Ulong4(uchar4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Short2Ulong2(short2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Short3Ulong3(short3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Short4Ulong4(short4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Ushort2Ulong2(ushort2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Ushort3Ulong3(ushort3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Ushort4Ulong4(ushort4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Int2Ulong2(int2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Int3Ulong3(int3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Int4Ulong4(int4 inV) {
    return convert_ulong4(inV);
}

ulong2 __attribute__((kernel)) testConvertUlong2Uint2Ulong2(uint2 inV) {
    return convert_ulong2(inV);
}

ulong3 __attribute__((kernel)) testConvertUlong3Uint3Ulong3(uint3 inV) {
    return convert_ulong3(inV);
}

ulong4 __attribute__((kernel)) testConvertUlong4Uint4Ulong4(uint4 inV) {
    return convert_ulong4(inV);
}