//
// AUTOGENERATED, DO NOT EDIT
//
// generated by parser_cl.py
enum OPENCL_FN_ID {
    OPENCL_FN_clBuildProgram = 0,
    OPENCL_FN_clCompileProgram = 1,
    OPENCL_FN_clCreateBuffer = 2,
    OPENCL_FN_clCreateCommandQueue = 3,
    OPENCL_FN_clCreateContext = 4,
    OPENCL_FN_clCreateContextFromType = 5,
    OPENCL_FN_clCreateImage = 6,
    OPENCL_FN_clCreateImage2D = 7,
    OPENCL_FN_clCreateImage3D = 8,
    OPENCL_FN_clCreateKernel = 9,
    OPENCL_FN_clCreateKernelsInProgram = 10,
    OPENCL_FN_clCreateProgramWithBinary = 11,
    OPENCL_FN_clCreateProgramWithBuiltInKernels = 12,
    OPENCL_FN_clCreateProgramWithSource = 13,
    OPENCL_FN_clCreateSampler = 14,
    OPENCL_FN_clCreateSubBuffer = 15,
    OPENCL_FN_clCreateSubDevices = 16,
    OPENCL_FN_clCreateUserEvent = 17,
    OPENCL_FN_clEnqueueBarrier = 18,
    OPENCL_FN_clEnqueueBarrierWithWaitList = 19,
    OPENCL_FN_clEnqueueCopyBuffer = 20,
    OPENCL_FN_clEnqueueCopyBufferRect = 21,
    OPENCL_FN_clEnqueueCopyBufferToImage = 22,
    OPENCL_FN_clEnqueueCopyImage = 23,
    OPENCL_FN_clEnqueueCopyImageToBuffer = 24,
    OPENCL_FN_clEnqueueFillBuffer = 25,
    OPENCL_FN_clEnqueueFillImage = 26,
    OPENCL_FN_clEnqueueMapBuffer = 27,
    OPENCL_FN_clEnqueueMapImage = 28,
    OPENCL_FN_clEnqueueMarker = 29,
    OPENCL_FN_clEnqueueMarkerWithWaitList = 30,
    OPENCL_FN_clEnqueueMigrateMemObjects = 31,
    OPENCL_FN_clEnqueueNDRangeKernel = 32,
    OPENCL_FN_clEnqueueNativeKernel = 33,
    OPENCL_FN_clEnqueueReadBuffer = 34,
    OPENCL_FN_clEnqueueReadBufferRect = 35,
    OPENCL_FN_clEnqueueReadImage = 36,
    OPENCL_FN_clEnqueueTask = 37,
    OPENCL_FN_clEnqueueUnmapMemObject = 38,
    OPENCL_FN_clEnqueueWaitForEvents = 39,
    OPENCL_FN_clEnqueueWriteBuffer = 40,
    OPENCL_FN_clEnqueueWriteBufferRect = 41,
    OPENCL_FN_clEnqueueWriteImage = 42,
    OPENCL_FN_clFinish = 43,
    OPENCL_FN_clFlush = 44,
    OPENCL_FN_clGetCommandQueueInfo = 45,
    OPENCL_FN_clGetContextInfo = 46,
    OPENCL_FN_clGetDeviceIDs = 47,
    OPENCL_FN_clGetDeviceInfo = 48,
    OPENCL_FN_clGetEventInfo = 49,
    OPENCL_FN_clGetEventProfilingInfo = 50,
    OPENCL_FN_clGetExtensionFunctionAddress = 51,
    OPENCL_FN_clGetExtensionFunctionAddressForPlatform = 52,
    OPENCL_FN_clGetImageInfo = 53,
    OPENCL_FN_clGetKernelArgInfo = 54,
    OPENCL_FN_clGetKernelInfo = 55,
    OPENCL_FN_clGetKernelWorkGroupInfo = 56,
    OPENCL_FN_clGetMemObjectInfo = 57,
    OPENCL_FN_clGetPlatformIDs = 58,
    OPENCL_FN_clGetPlatformInfo = 59,
    OPENCL_FN_clGetProgramBuildInfo = 60,
    OPENCL_FN_clGetProgramInfo = 61,
    OPENCL_FN_clGetSamplerInfo = 62,
    OPENCL_FN_clGetSupportedImageFormats = 63,
    OPENCL_FN_clLinkProgram = 64,
    OPENCL_FN_clReleaseCommandQueue = 65,
    OPENCL_FN_clReleaseContext = 66,
    OPENCL_FN_clReleaseDevice = 67,
    OPENCL_FN_clReleaseEvent = 68,
    OPENCL_FN_clReleaseKernel = 69,
    OPENCL_FN_clReleaseMemObject = 70,
    OPENCL_FN_clReleaseProgram = 71,
    OPENCL_FN_clReleaseSampler = 72,
    OPENCL_FN_clRetainCommandQueue = 73,
    OPENCL_FN_clRetainContext = 74,
    OPENCL_FN_clRetainDevice = 75,
    OPENCL_FN_clRetainEvent = 76,
    OPENCL_FN_clRetainKernel = 77,
    OPENCL_FN_clRetainMemObject = 78,
    OPENCL_FN_clRetainProgram = 79,
    OPENCL_FN_clRetainSampler = 80,
    OPENCL_FN_clSetEventCallback = 81,
    OPENCL_FN_clSetKernelArg = 82,
    OPENCL_FN_clSetMemObjectDestructorCallback = 83,
    OPENCL_FN_clSetUserEventStatus = 84,
    OPENCL_FN_clUnloadCompiler = 85,
    OPENCL_FN_clUnloadPlatformCompiler = 86,
    OPENCL_FN_clWaitForEvents = 87,
};

namespace {
// generated by parser_cl.py
template <int ID, typename _R>
struct opencl_fn0
{
    typedef _R (CL_API_CALL*FN)();
    static _R CL_API_CALL switch_fn()
    { return ((FN)opencl_check_fn(ID))(); }
};

template <int ID, typename _R, typename _T1>
struct opencl_fn1
{
    typedef _R (CL_API_CALL*FN)(_T1);
    static _R CL_API_CALL switch_fn(_T1 p1)
    { return ((FN)opencl_check_fn(ID))(p1); }
};

template <int ID, typename _R, typename _T1, typename _T2>
struct opencl_fn2
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2)
    { return ((FN)opencl_check_fn(ID))(p1, p2); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3>
struct opencl_fn3
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4>
struct opencl_fn4
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5>
struct opencl_fn5
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6>
struct opencl_fn6
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7>
struct opencl_fn7
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8>
struct opencl_fn8
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9>
struct opencl_fn9
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8, _T9 p9)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10>
struct opencl_fn10
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8, _T9 p9, _T10 p10)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11>
struct opencl_fn11
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8, _T9 p9, _T10 p10, _T11 p11)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12>
struct opencl_fn12
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8, _T9 p9, _T10 p10, _T11 p11, _T12 p12)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13>
struct opencl_fn13
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8, _T9 p9, _T10 p10, _T11 p11, _T12 p12, _T13 p13)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
};

template <int ID, typename _R, typename _T1, typename _T2, typename _T3, typename _T4, typename _T5, typename _T6, typename _T7, typename _T8, typename _T9, typename _T10, typename _T11, typename _T12, typename _T13, typename _T14>
struct opencl_fn14
{
    typedef _R (CL_API_CALL*FN)(_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10, _T11, _T12, _T13, _T14);
    static _R CL_API_CALL switch_fn(_T1 p1, _T2 p2, _T3 p3, _T4 p4, _T5 p5, _T6 p6, _T7 p7, _T8 p8, _T9 p9, _T10 p10, _T11 p11, _T12 p12, _T13 p13, _T14 p14)
    { return ((FN)opencl_check_fn(ID))(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
};

} // anonymous namespace

// generated by parser_cl.py
cl_int (CL_API_CALL*clBuildProgram)(cl_program, cl_uint, const cl_device_id*, const char*, void (CL_CALLBACK*) (cl_program, void*), void*) =
        opencl_fn6<OPENCL_FN_clBuildProgram, cl_int, cl_program, cl_uint, const cl_device_id*, const char*, void (CL_CALLBACK*) (cl_program, void*), void*>::switch_fn;
static const struct DynamicFnEntry clBuildProgram_definition = { "clBuildProgram", (void**)&clBuildProgram};

cl_int (CL_API_CALL*clCompileProgram)(cl_program, cl_uint, const cl_device_id*, const char*, cl_uint, const cl_program*, const char**, void (CL_CALLBACK*) (cl_program, void*), void*) =
        opencl_fn9<OPENCL_FN_clCompileProgram, cl_int, cl_program, cl_uint, const cl_device_id*, const char*, cl_uint, const cl_program*, const char**, void (CL_CALLBACK*) (cl_program, void*), void*>::switch_fn;
static const struct DynamicFnEntry clCompileProgram_definition = { "clCompileProgram", (void**)&clCompileProgram};

cl_mem (CL_API_CALL*clCreateBuffer)(cl_context, cl_mem_flags, size_t, void*, cl_int*) =
        opencl_fn5<OPENCL_FN_clCreateBuffer, cl_mem, cl_context, cl_mem_flags, size_t, void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateBuffer_definition = { "clCreateBuffer", (void**)&clCreateBuffer};

cl_command_queue (CL_API_CALL*clCreateCommandQueue)(cl_context, cl_device_id, cl_command_queue_properties, cl_int*) =
        opencl_fn4<OPENCL_FN_clCreateCommandQueue, cl_command_queue, cl_context, cl_device_id, cl_command_queue_properties, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateCommandQueue_definition = { "clCreateCommandQueue", (void**)&clCreateCommandQueue};

cl_context (CL_API_CALL*clCreateContext)(const cl_context_properties*, cl_uint, const cl_device_id*, void (CL_CALLBACK*) (const char*, const void*, size_t, void*), void*, cl_int*) =
        opencl_fn6<OPENCL_FN_clCreateContext, cl_context, const cl_context_properties*, cl_uint, const cl_device_id*, void (CL_CALLBACK*) (const char*, const void*, size_t, void*), void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateContext_definition = { "clCreateContext", (void**)&clCreateContext};

cl_context (CL_API_CALL*clCreateContextFromType)(const cl_context_properties*, cl_device_type, void (CL_CALLBACK*) (const char*, const void*, size_t, void*), void*, cl_int*) =
        opencl_fn5<OPENCL_FN_clCreateContextFromType, cl_context, const cl_context_properties*, cl_device_type, void (CL_CALLBACK*) (const char*, const void*, size_t, void*), void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateContextFromType_definition = { "clCreateContextFromType", (void**)&clCreateContextFromType};

cl_mem (CL_API_CALL*clCreateImage)(cl_context, cl_mem_flags, const cl_image_format*, const cl_image_desc*, void*, cl_int*) =
        opencl_fn6<OPENCL_FN_clCreateImage, cl_mem, cl_context, cl_mem_flags, const cl_image_format*, const cl_image_desc*, void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateImage_definition = { "clCreateImage", (void**)&clCreateImage};

cl_mem (CL_API_CALL*clCreateImage2D)(cl_context, cl_mem_flags, const cl_image_format*, size_t, size_t, size_t, void*, cl_int*) =
        opencl_fn8<OPENCL_FN_clCreateImage2D, cl_mem, cl_context, cl_mem_flags, const cl_image_format*, size_t, size_t, size_t, void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateImage2D_definition = { "clCreateImage2D", (void**)&clCreateImage2D};

cl_mem (CL_API_CALL*clCreateImage3D)(cl_context, cl_mem_flags, const cl_image_format*, size_t, size_t, size_t, size_t, size_t, void*, cl_int*) =
        opencl_fn10<OPENCL_FN_clCreateImage3D, cl_mem, cl_context, cl_mem_flags, const cl_image_format*, size_t, size_t, size_t, size_t, size_t, void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateImage3D_definition = { "clCreateImage3D", (void**)&clCreateImage3D};

cl_kernel (CL_API_CALL*clCreateKernel)(cl_program, const char*, cl_int*) =
        opencl_fn3<OPENCL_FN_clCreateKernel, cl_kernel, cl_program, const char*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateKernel_definition = { "clCreateKernel", (void**)&clCreateKernel};

cl_int (CL_API_CALL*clCreateKernelsInProgram)(cl_program, cl_uint, cl_kernel*, cl_uint*) =
        opencl_fn4<OPENCL_FN_clCreateKernelsInProgram, cl_int, cl_program, cl_uint, cl_kernel*, cl_uint*>::switch_fn;
static const struct DynamicFnEntry clCreateKernelsInProgram_definition = { "clCreateKernelsInProgram", (void**)&clCreateKernelsInProgram};

cl_program (CL_API_CALL*clCreateProgramWithBinary)(cl_context, cl_uint, const cl_device_id*, const size_t*, const unsigned char**, cl_int*, cl_int*) =
        opencl_fn7<OPENCL_FN_clCreateProgramWithBinary, cl_program, cl_context, cl_uint, const cl_device_id*, const size_t*, const unsigned char**, cl_int*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateProgramWithBinary_definition = { "clCreateProgramWithBinary", (void**)&clCreateProgramWithBinary};

cl_program (CL_API_CALL*clCreateProgramWithBuiltInKernels)(cl_context, cl_uint, const cl_device_id*, const char*, cl_int*) =
        opencl_fn5<OPENCL_FN_clCreateProgramWithBuiltInKernels, cl_program, cl_context, cl_uint, const cl_device_id*, const char*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateProgramWithBuiltInKernels_definition = { "clCreateProgramWithBuiltInKernels", (void**)&clCreateProgramWithBuiltInKernels};

cl_program (CL_API_CALL*clCreateProgramWithSource)(cl_context, cl_uint, const char**, const size_t*, cl_int*) =
        opencl_fn5<OPENCL_FN_clCreateProgramWithSource, cl_program, cl_context, cl_uint, const char**, const size_t*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateProgramWithSource_definition = { "clCreateProgramWithSource", (void**)&clCreateProgramWithSource};

cl_sampler (CL_API_CALL*clCreateSampler)(cl_context, cl_bool, cl_addressing_mode, cl_filter_mode, cl_int*) =
        opencl_fn5<OPENCL_FN_clCreateSampler, cl_sampler, cl_context, cl_bool, cl_addressing_mode, cl_filter_mode, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateSampler_definition = { "clCreateSampler", (void**)&clCreateSampler};

cl_mem (CL_API_CALL*clCreateSubBuffer)(cl_mem, cl_mem_flags, cl_buffer_create_type, const void*, cl_int*) =
        opencl_fn5<OPENCL_FN_clCreateSubBuffer, cl_mem, cl_mem, cl_mem_flags, cl_buffer_create_type, const void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateSubBuffer_definition = { "clCreateSubBuffer", (void**)&clCreateSubBuffer};

cl_int (CL_API_CALL*clCreateSubDevices)(cl_device_id, const cl_device_partition_property*, cl_uint, cl_device_id*, cl_uint*) =
        opencl_fn5<OPENCL_FN_clCreateSubDevices, cl_int, cl_device_id, const cl_device_partition_property*, cl_uint, cl_device_id*, cl_uint*>::switch_fn;
static const struct DynamicFnEntry clCreateSubDevices_definition = { "clCreateSubDevices", (void**)&clCreateSubDevices};

cl_event (CL_API_CALL*clCreateUserEvent)(cl_context, cl_int*) =
        opencl_fn2<OPENCL_FN_clCreateUserEvent, cl_event, cl_context, cl_int*>::switch_fn;
static const struct DynamicFnEntry clCreateUserEvent_definition = { "clCreateUserEvent", (void**)&clCreateUserEvent};

cl_int (CL_API_CALL*clEnqueueBarrier)(cl_command_queue) =
        opencl_fn1<OPENCL_FN_clEnqueueBarrier, cl_int, cl_command_queue>::switch_fn;
static const struct DynamicFnEntry clEnqueueBarrier_definition = { "clEnqueueBarrier", (void**)&clEnqueueBarrier};

cl_int (CL_API_CALL*clEnqueueBarrierWithWaitList)(cl_command_queue, cl_uint, const cl_event*, cl_event*) =
        opencl_fn4<OPENCL_FN_clEnqueueBarrierWithWaitList, cl_int, cl_command_queue, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueBarrierWithWaitList_definition = { "clEnqueueBarrierWithWaitList", (void**)&clEnqueueBarrierWithWaitList};

cl_int (CL_API_CALL*clEnqueueCopyBuffer)(cl_command_queue, cl_mem, cl_mem, size_t, size_t, size_t, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueCopyBuffer, cl_int, cl_command_queue, cl_mem, cl_mem, size_t, size_t, size_t, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueCopyBuffer_definition = { "clEnqueueCopyBuffer", (void**)&clEnqueueCopyBuffer};

cl_int (CL_API_CALL*clEnqueueCopyBufferRect)(cl_command_queue, cl_mem, cl_mem, const size_t*, const size_t*, const size_t*, size_t, size_t, size_t, size_t, cl_uint, const cl_event*, cl_event*) =
        opencl_fn13<OPENCL_FN_clEnqueueCopyBufferRect, cl_int, cl_command_queue, cl_mem, cl_mem, const size_t*, const size_t*, const size_t*, size_t, size_t, size_t, size_t, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueCopyBufferRect_definition = { "clEnqueueCopyBufferRect", (void**)&clEnqueueCopyBufferRect};

cl_int (CL_API_CALL*clEnqueueCopyBufferToImage)(cl_command_queue, cl_mem, cl_mem, size_t, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueCopyBufferToImage, cl_int, cl_command_queue, cl_mem, cl_mem, size_t, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueCopyBufferToImage_definition = { "clEnqueueCopyBufferToImage", (void**)&clEnqueueCopyBufferToImage};

cl_int (CL_API_CALL*clEnqueueCopyImage)(cl_command_queue, cl_mem, cl_mem, const size_t*, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueCopyImage, cl_int, cl_command_queue, cl_mem, cl_mem, const size_t*, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueCopyImage_definition = { "clEnqueueCopyImage", (void**)&clEnqueueCopyImage};

cl_int (CL_API_CALL*clEnqueueCopyImageToBuffer)(cl_command_queue, cl_mem, cl_mem, const size_t*, const size_t*, size_t, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueCopyImageToBuffer, cl_int, cl_command_queue, cl_mem, cl_mem, const size_t*, const size_t*, size_t, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueCopyImageToBuffer_definition = { "clEnqueueCopyImageToBuffer", (void**)&clEnqueueCopyImageToBuffer};

cl_int (CL_API_CALL*clEnqueueFillBuffer)(cl_command_queue, cl_mem, const void*, size_t, size_t, size_t, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueFillBuffer, cl_int, cl_command_queue, cl_mem, const void*, size_t, size_t, size_t, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueFillBuffer_definition = { "clEnqueueFillBuffer", (void**)&clEnqueueFillBuffer};

cl_int (CL_API_CALL*clEnqueueFillImage)(cl_command_queue, cl_mem, const void*, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn8<OPENCL_FN_clEnqueueFillImage, cl_int, cl_command_queue, cl_mem, const void*, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueFillImage_definition = { "clEnqueueFillImage", (void**)&clEnqueueFillImage};

void* (CL_API_CALL*clEnqueueMapBuffer)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint, const cl_event*, cl_event*, cl_int*) =
        opencl_fn10<OPENCL_FN_clEnqueueMapBuffer, void*, cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint, const cl_event*, cl_event*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clEnqueueMapBuffer_definition = { "clEnqueueMapBuffer", (void**)&clEnqueueMapBuffer};

void* (CL_API_CALL*clEnqueueMapImage)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, const size_t*, const size_t*, size_t*, size_t*, cl_uint, const cl_event*, cl_event*, cl_int*) =
        opencl_fn12<OPENCL_FN_clEnqueueMapImage, void*, cl_command_queue, cl_mem, cl_bool, cl_map_flags, const size_t*, const size_t*, size_t*, size_t*, cl_uint, const cl_event*, cl_event*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clEnqueueMapImage_definition = { "clEnqueueMapImage", (void**)&clEnqueueMapImage};

cl_int (CL_API_CALL*clEnqueueMarker)(cl_command_queue, cl_event*) =
        opencl_fn2<OPENCL_FN_clEnqueueMarker, cl_int, cl_command_queue, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueMarker_definition = { "clEnqueueMarker", (void**)&clEnqueueMarker};

cl_int (CL_API_CALL*clEnqueueMarkerWithWaitList)(cl_command_queue, cl_uint, const cl_event*, cl_event*) =
        opencl_fn4<OPENCL_FN_clEnqueueMarkerWithWaitList, cl_int, cl_command_queue, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueMarkerWithWaitList_definition = { "clEnqueueMarkerWithWaitList", (void**)&clEnqueueMarkerWithWaitList};

cl_int (CL_API_CALL*clEnqueueMigrateMemObjects)(cl_command_queue, cl_uint, const cl_mem*, cl_mem_migration_flags, cl_uint, const cl_event*, cl_event*) =
        opencl_fn7<OPENCL_FN_clEnqueueMigrateMemObjects, cl_int, cl_command_queue, cl_uint, const cl_mem*, cl_mem_migration_flags, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueMigrateMemObjects_definition = { "clEnqueueMigrateMemObjects", (void**)&clEnqueueMigrateMemObjects};

cl_int (CL_API_CALL*clEnqueueNDRangeKernel)(cl_command_queue, cl_kernel, cl_uint, const size_t*, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueNDRangeKernel, cl_int, cl_command_queue, cl_kernel, cl_uint, const size_t*, const size_t*, const size_t*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueNDRangeKernel_definition = { "clEnqueueNDRangeKernel", (void**)&clEnqueueNDRangeKernel};

cl_int (CL_API_CALL*clEnqueueNativeKernel)(cl_command_queue, void (CL_CALLBACK*) (void*), void*, size_t, cl_uint, const cl_mem*, const void**, cl_uint, const cl_event*, cl_event*) =
        opencl_fn10<OPENCL_FN_clEnqueueNativeKernel, cl_int, cl_command_queue, void (CL_CALLBACK*) (void*), void*, size_t, cl_uint, const cl_mem*, const void**, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueNativeKernel_definition = { "clEnqueueNativeKernel", (void**)&clEnqueueNativeKernel};

cl_int (CL_API_CALL*clEnqueueReadBuffer)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueReadBuffer, cl_int, cl_command_queue, cl_mem, cl_bool, size_t, size_t, void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueReadBuffer_definition = { "clEnqueueReadBuffer", (void**)&clEnqueueReadBuffer};

cl_int (CL_API_CALL*clEnqueueReadBufferRect)(cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, const size_t*, size_t, size_t, size_t, size_t, void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn14<OPENCL_FN_clEnqueueReadBufferRect, cl_int, cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, const size_t*, size_t, size_t, size_t, size_t, void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueReadBufferRect_definition = { "clEnqueueReadBufferRect", (void**)&clEnqueueReadBufferRect};

cl_int (CL_API_CALL*clEnqueueReadImage)(cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, size_t, size_t, void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn11<OPENCL_FN_clEnqueueReadImage, cl_int, cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, size_t, size_t, void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueReadImage_definition = { "clEnqueueReadImage", (void**)&clEnqueueReadImage};

cl_int (CL_API_CALL*clEnqueueTask)(cl_command_queue, cl_kernel, cl_uint, const cl_event*, cl_event*) =
        opencl_fn5<OPENCL_FN_clEnqueueTask, cl_int, cl_command_queue, cl_kernel, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueTask_definition = { "clEnqueueTask", (void**)&clEnqueueTask};

cl_int (CL_API_CALL*clEnqueueUnmapMemObject)(cl_command_queue, cl_mem, void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn6<OPENCL_FN_clEnqueueUnmapMemObject, cl_int, cl_command_queue, cl_mem, void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueUnmapMemObject_definition = { "clEnqueueUnmapMemObject", (void**)&clEnqueueUnmapMemObject};

cl_int (CL_API_CALL*clEnqueueWaitForEvents)(cl_command_queue, cl_uint, const cl_event*) =
        opencl_fn3<OPENCL_FN_clEnqueueWaitForEvents, cl_int, cl_command_queue, cl_uint, const cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueWaitForEvents_definition = { "clEnqueueWaitForEvents", (void**)&clEnqueueWaitForEvents};

cl_int (CL_API_CALL*clEnqueueWriteBuffer)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn9<OPENCL_FN_clEnqueueWriteBuffer, cl_int, cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueWriteBuffer_definition = { "clEnqueueWriteBuffer", (void**)&clEnqueueWriteBuffer};

cl_int (CL_API_CALL*clEnqueueWriteBufferRect)(cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, const size_t*, size_t, size_t, size_t, size_t, const void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn14<OPENCL_FN_clEnqueueWriteBufferRect, cl_int, cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, const size_t*, size_t, size_t, size_t, size_t, const void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueWriteBufferRect_definition = { "clEnqueueWriteBufferRect", (void**)&clEnqueueWriteBufferRect};

cl_int (CL_API_CALL*clEnqueueWriteImage)(cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, size_t, size_t, const void*, cl_uint, const cl_event*, cl_event*) =
        opencl_fn11<OPENCL_FN_clEnqueueWriteImage, cl_int, cl_command_queue, cl_mem, cl_bool, const size_t*, const size_t*, size_t, size_t, const void*, cl_uint, const cl_event*, cl_event*>::switch_fn;
static const struct DynamicFnEntry clEnqueueWriteImage_definition = { "clEnqueueWriteImage", (void**)&clEnqueueWriteImage};

cl_int (CL_API_CALL*clFinish)(cl_command_queue) =
        opencl_fn1<OPENCL_FN_clFinish, cl_int, cl_command_queue>::switch_fn;
static const struct DynamicFnEntry clFinish_definition = { "clFinish", (void**)&clFinish};

cl_int (CL_API_CALL*clFlush)(cl_command_queue) =
        opencl_fn1<OPENCL_FN_clFlush, cl_int, cl_command_queue>::switch_fn;
static const struct DynamicFnEntry clFlush_definition = { "clFlush", (void**)&clFlush};

cl_int (CL_API_CALL*clGetCommandQueueInfo)(cl_command_queue, cl_command_queue_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetCommandQueueInfo, cl_int, cl_command_queue, cl_command_queue_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetCommandQueueInfo_definition = { "clGetCommandQueueInfo", (void**)&clGetCommandQueueInfo};

cl_int (CL_API_CALL*clGetContextInfo)(cl_context, cl_context_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetContextInfo, cl_int, cl_context, cl_context_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetContextInfo_definition = { "clGetContextInfo", (void**)&clGetContextInfo};

cl_int (CL_API_CALL*clGetDeviceIDs)(cl_platform_id, cl_device_type, cl_uint, cl_device_id*, cl_uint*) =
        opencl_fn5<OPENCL_FN_clGetDeviceIDs, cl_int, cl_platform_id, cl_device_type, cl_uint, cl_device_id*, cl_uint*>::switch_fn;
static const struct DynamicFnEntry clGetDeviceIDs_definition = { "clGetDeviceIDs", (void**)&clGetDeviceIDs};

cl_int (CL_API_CALL*clGetDeviceInfo)(cl_device_id, cl_device_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetDeviceInfo, cl_int, cl_device_id, cl_device_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetDeviceInfo_definition = { "clGetDeviceInfo", (void**)&clGetDeviceInfo};

cl_int (CL_API_CALL*clGetEventInfo)(cl_event, cl_event_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetEventInfo, cl_int, cl_event, cl_event_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetEventInfo_definition = { "clGetEventInfo", (void**)&clGetEventInfo};

cl_int (CL_API_CALL*clGetEventProfilingInfo)(cl_event, cl_profiling_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetEventProfilingInfo, cl_int, cl_event, cl_profiling_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetEventProfilingInfo_definition = { "clGetEventProfilingInfo", (void**)&clGetEventProfilingInfo};

void* (CL_API_CALL*clGetExtensionFunctionAddress)(const char*) =
        opencl_fn1<OPENCL_FN_clGetExtensionFunctionAddress, void*, const char*>::switch_fn;
static const struct DynamicFnEntry clGetExtensionFunctionAddress_definition = { "clGetExtensionFunctionAddress", (void**)&clGetExtensionFunctionAddress};

void* (CL_API_CALL*clGetExtensionFunctionAddressForPlatform)(cl_platform_id, const char*) =
        opencl_fn2<OPENCL_FN_clGetExtensionFunctionAddressForPlatform, void*, cl_platform_id, const char*>::switch_fn;
static const struct DynamicFnEntry clGetExtensionFunctionAddressForPlatform_definition = { "clGetExtensionFunctionAddressForPlatform", (void**)&clGetExtensionFunctionAddressForPlatform};

cl_int (CL_API_CALL*clGetImageInfo)(cl_mem, cl_image_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetImageInfo, cl_int, cl_mem, cl_image_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetImageInfo_definition = { "clGetImageInfo", (void**)&clGetImageInfo};

cl_int (CL_API_CALL*clGetKernelArgInfo)(cl_kernel, cl_uint, cl_kernel_arg_info, size_t, void*, size_t*) =
        opencl_fn6<OPENCL_FN_clGetKernelArgInfo, cl_int, cl_kernel, cl_uint, cl_kernel_arg_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetKernelArgInfo_definition = { "clGetKernelArgInfo", (void**)&clGetKernelArgInfo};

cl_int (CL_API_CALL*clGetKernelInfo)(cl_kernel, cl_kernel_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetKernelInfo, cl_int, cl_kernel, cl_kernel_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetKernelInfo_definition = { "clGetKernelInfo", (void**)&clGetKernelInfo};

cl_int (CL_API_CALL*clGetKernelWorkGroupInfo)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void*, size_t*) =
        opencl_fn6<OPENCL_FN_clGetKernelWorkGroupInfo, cl_int, cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetKernelWorkGroupInfo_definition = { "clGetKernelWorkGroupInfo", (void**)&clGetKernelWorkGroupInfo};

cl_int (CL_API_CALL*clGetMemObjectInfo)(cl_mem, cl_mem_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetMemObjectInfo, cl_int, cl_mem, cl_mem_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetMemObjectInfo_definition = { "clGetMemObjectInfo", (void**)&clGetMemObjectInfo};

cl_int (CL_API_CALL*clGetPlatformIDs)(cl_uint, cl_platform_id*, cl_uint*) =
        opencl_fn3<OPENCL_FN_clGetPlatformIDs, cl_int, cl_uint, cl_platform_id*, cl_uint*>::switch_fn;
static const struct DynamicFnEntry clGetPlatformIDs_definition = { "clGetPlatformIDs", (void**)&clGetPlatformIDs};

cl_int (CL_API_CALL*clGetPlatformInfo)(cl_platform_id, cl_platform_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetPlatformInfo, cl_int, cl_platform_id, cl_platform_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetPlatformInfo_definition = { "clGetPlatformInfo", (void**)&clGetPlatformInfo};

cl_int (CL_API_CALL*clGetProgramBuildInfo)(cl_program, cl_device_id, cl_program_build_info, size_t, void*, size_t*) =
        opencl_fn6<OPENCL_FN_clGetProgramBuildInfo, cl_int, cl_program, cl_device_id, cl_program_build_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetProgramBuildInfo_definition = { "clGetProgramBuildInfo", (void**)&clGetProgramBuildInfo};

cl_int (CL_API_CALL*clGetProgramInfo)(cl_program, cl_program_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetProgramInfo, cl_int, cl_program, cl_program_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetProgramInfo_definition = { "clGetProgramInfo", (void**)&clGetProgramInfo};

cl_int (CL_API_CALL*clGetSamplerInfo)(cl_sampler, cl_sampler_info, size_t, void*, size_t*) =
        opencl_fn5<OPENCL_FN_clGetSamplerInfo, cl_int, cl_sampler, cl_sampler_info, size_t, void*, size_t*>::switch_fn;
static const struct DynamicFnEntry clGetSamplerInfo_definition = { "clGetSamplerInfo", (void**)&clGetSamplerInfo};

cl_int (CL_API_CALL*clGetSupportedImageFormats)(cl_context, cl_mem_flags, cl_mem_object_type, cl_uint, cl_image_format*, cl_uint*) =
        opencl_fn6<OPENCL_FN_clGetSupportedImageFormats, cl_int, cl_context, cl_mem_flags, cl_mem_object_type, cl_uint, cl_image_format*, cl_uint*>::switch_fn;
static const struct DynamicFnEntry clGetSupportedImageFormats_definition = { "clGetSupportedImageFormats", (void**)&clGetSupportedImageFormats};

cl_program (CL_API_CALL*clLinkProgram)(cl_context, cl_uint, const cl_device_id*, const char*, cl_uint, const cl_program*, void (CL_CALLBACK*) (cl_program, void*), void*, cl_int*) =
        opencl_fn9<OPENCL_FN_clLinkProgram, cl_program, cl_context, cl_uint, const cl_device_id*, const char*, cl_uint, const cl_program*, void (CL_CALLBACK*) (cl_program, void*), void*, cl_int*>::switch_fn;
static const struct DynamicFnEntry clLinkProgram_definition = { "clLinkProgram", (void**)&clLinkProgram};

cl_int (CL_API_CALL*clReleaseCommandQueue)(cl_command_queue) =
        opencl_fn1<OPENCL_FN_clReleaseCommandQueue, cl_int, cl_command_queue>::switch_fn;
static const struct DynamicFnEntry clReleaseCommandQueue_definition = { "clReleaseCommandQueue", (void**)&clReleaseCommandQueue};

cl_int (CL_API_CALL*clReleaseContext)(cl_context) =
        opencl_fn1<OPENCL_FN_clReleaseContext, cl_int, cl_context>::switch_fn;
static const struct DynamicFnEntry clReleaseContext_definition = { "clReleaseContext", (void**)&clReleaseContext};

cl_int (CL_API_CALL*clReleaseDevice)(cl_device_id) =
        opencl_fn1<OPENCL_FN_clReleaseDevice, cl_int, cl_device_id>::switch_fn;
static const struct DynamicFnEntry clReleaseDevice_definition = { "clReleaseDevice", (void**)&clReleaseDevice};

cl_int (CL_API_CALL*clReleaseEvent)(cl_event) =
        opencl_fn1<OPENCL_FN_clReleaseEvent, cl_int, cl_event>::switch_fn;
static const struct DynamicFnEntry clReleaseEvent_definition = { "clReleaseEvent", (void**)&clReleaseEvent};

cl_int (CL_API_CALL*clReleaseKernel)(cl_kernel) =
        opencl_fn1<OPENCL_FN_clReleaseKernel, cl_int, cl_kernel>::switch_fn;
static const struct DynamicFnEntry clReleaseKernel_definition = { "clReleaseKernel", (void**)&clReleaseKernel};

cl_int (CL_API_CALL*clReleaseMemObject)(cl_mem) =
        opencl_fn1<OPENCL_FN_clReleaseMemObject, cl_int, cl_mem>::switch_fn;
static const struct DynamicFnEntry clReleaseMemObject_definition = { "clReleaseMemObject", (void**)&clReleaseMemObject};

cl_int (CL_API_CALL*clReleaseProgram)(cl_program) =
        opencl_fn1<OPENCL_FN_clReleaseProgram, cl_int, cl_program>::switch_fn;
static const struct DynamicFnEntry clReleaseProgram_definition = { "clReleaseProgram", (void**)&clReleaseProgram};

cl_int (CL_API_CALL*clReleaseSampler)(cl_sampler) =
        opencl_fn1<OPENCL_FN_clReleaseSampler, cl_int, cl_sampler>::switch_fn;
static const struct DynamicFnEntry clReleaseSampler_definition = { "clReleaseSampler", (void**)&clReleaseSampler};

cl_int (CL_API_CALL*clRetainCommandQueue)(cl_command_queue) =
        opencl_fn1<OPENCL_FN_clRetainCommandQueue, cl_int, cl_command_queue>::switch_fn;
static const struct DynamicFnEntry clRetainCommandQueue_definition = { "clRetainCommandQueue", (void**)&clRetainCommandQueue};

cl_int (CL_API_CALL*clRetainContext)(cl_context) =
        opencl_fn1<OPENCL_FN_clRetainContext, cl_int, cl_context>::switch_fn;
static const struct DynamicFnEntry clRetainContext_definition = { "clRetainContext", (void**)&clRetainContext};

cl_int (CL_API_CALL*clRetainDevice)(cl_device_id) =
        opencl_fn1<OPENCL_FN_clRetainDevice, cl_int, cl_device_id>::switch_fn;
static const struct DynamicFnEntry clRetainDevice_definition = { "clRetainDevice", (void**)&clRetainDevice};

cl_int (CL_API_CALL*clRetainEvent)(cl_event) =
        opencl_fn1<OPENCL_FN_clRetainEvent, cl_int, cl_event>::switch_fn;
static const struct DynamicFnEntry clRetainEvent_definition = { "clRetainEvent", (void**)&clRetainEvent};

cl_int (CL_API_CALL*clRetainKernel)(cl_kernel) =
        opencl_fn1<OPENCL_FN_clRetainKernel, cl_int, cl_kernel>::switch_fn;
static const struct DynamicFnEntry clRetainKernel_definition = { "clRetainKernel", (void**)&clRetainKernel};

cl_int (CL_API_CALL*clRetainMemObject)(cl_mem) =
        opencl_fn1<OPENCL_FN_clRetainMemObject, cl_int, cl_mem>::switch_fn;
static const struct DynamicFnEntry clRetainMemObject_definition = { "clRetainMemObject", (void**)&clRetainMemObject};

cl_int (CL_API_CALL*clRetainProgram)(cl_program) =
        opencl_fn1<OPENCL_FN_clRetainProgram, cl_int, cl_program>::switch_fn;
static const struct DynamicFnEntry clRetainProgram_definition = { "clRetainProgram", (void**)&clRetainProgram};

cl_int (CL_API_CALL*clRetainSampler)(cl_sampler) =
        opencl_fn1<OPENCL_FN_clRetainSampler, cl_int, cl_sampler>::switch_fn;
static const struct DynamicFnEntry clRetainSampler_definition = { "clRetainSampler", (void**)&clRetainSampler};

cl_int (CL_API_CALL*clSetEventCallback)(cl_event, cl_int, void (CL_CALLBACK*) (cl_event, cl_int, void*), void*) =
        opencl_fn4<OPENCL_FN_clSetEventCallback, cl_int, cl_event, cl_int, void (CL_CALLBACK*) (cl_event, cl_int, void*), void*>::switch_fn;
static const struct DynamicFnEntry clSetEventCallback_definition = { "clSetEventCallback", (void**)&clSetEventCallback};

cl_int (CL_API_CALL*clSetKernelArg)(cl_kernel, cl_uint, size_t, const void*) =
        opencl_fn4<OPENCL_FN_clSetKernelArg, cl_int, cl_kernel, cl_uint, size_t, const void*>::switch_fn;
static const struct DynamicFnEntry clSetKernelArg_definition = { "clSetKernelArg", (void**)&clSetKernelArg};

cl_int (CL_API_CALL*clSetMemObjectDestructorCallback)(cl_mem, void (CL_CALLBACK*) (cl_mem, void*), void*) =
        opencl_fn3<OPENCL_FN_clSetMemObjectDestructorCallback, cl_int, cl_mem, void (CL_CALLBACK*) (cl_mem, void*), void*>::switch_fn;
static const struct DynamicFnEntry clSetMemObjectDestructorCallback_definition = { "clSetMemObjectDestructorCallback", (void**)&clSetMemObjectDestructorCallback};

cl_int (CL_API_CALL*clSetUserEventStatus)(cl_event, cl_int) =
        opencl_fn2<OPENCL_FN_clSetUserEventStatus, cl_int, cl_event, cl_int>::switch_fn;
static const struct DynamicFnEntry clSetUserEventStatus_definition = { "clSetUserEventStatus", (void**)&clSetUserEventStatus};

cl_int (CL_API_CALL*clUnloadCompiler)() =
        opencl_fn0<OPENCL_FN_clUnloadCompiler, cl_int>::switch_fn;
static const struct DynamicFnEntry clUnloadCompiler_definition = { "clUnloadCompiler", (void**)&clUnloadCompiler};

cl_int (CL_API_CALL*clUnloadPlatformCompiler)(cl_platform_id) =
        opencl_fn1<OPENCL_FN_clUnloadPlatformCompiler, cl_int, cl_platform_id>::switch_fn;
static const struct DynamicFnEntry clUnloadPlatformCompiler_definition = { "clUnloadPlatformCompiler", (void**)&clUnloadPlatformCompiler};

cl_int (CL_API_CALL*clWaitForEvents)(cl_uint, const cl_event*) =
        opencl_fn2<OPENCL_FN_clWaitForEvents, cl_int, cl_uint, const cl_event*>::switch_fn;
static const struct DynamicFnEntry clWaitForEvents_definition = { "clWaitForEvents", (void**)&clWaitForEvents};


// generated by parser_cl.py
static const struct DynamicFnEntry* opencl_fn_list[] = {
    &clBuildProgram_definition,
    &clCompileProgram_definition,
    &clCreateBuffer_definition,
    &clCreateCommandQueue_definition,
    &clCreateContext_definition,
    &clCreateContextFromType_definition,
    &clCreateImage_definition,
    &clCreateImage2D_definition,
    &clCreateImage3D_definition,
    &clCreateKernel_definition,
    &clCreateKernelsInProgram_definition,
    &clCreateProgramWithBinary_definition,
    &clCreateProgramWithBuiltInKernels_definition,
    &clCreateProgramWithSource_definition,
    &clCreateSampler_definition,
    &clCreateSubBuffer_definition,
    &clCreateSubDevices_definition,
    &clCreateUserEvent_definition,
    &clEnqueueBarrier_definition,
    &clEnqueueBarrierWithWaitList_definition,
    &clEnqueueCopyBuffer_definition,
    &clEnqueueCopyBufferRect_definition,
    &clEnqueueCopyBufferToImage_definition,
    &clEnqueueCopyImage_definition,
    &clEnqueueCopyImageToBuffer_definition,
    &clEnqueueFillBuffer_definition,
    &clEnqueueFillImage_definition,
    &clEnqueueMapBuffer_definition,
    &clEnqueueMapImage_definition,
    &clEnqueueMarker_definition,
    &clEnqueueMarkerWithWaitList_definition,
    &clEnqueueMigrateMemObjects_definition,
    &clEnqueueNDRangeKernel_definition,
    &clEnqueueNativeKernel_definition,
    &clEnqueueReadBuffer_definition,
    &clEnqueueReadBufferRect_definition,
    &clEnqueueReadImage_definition,
    &clEnqueueTask_definition,
    &clEnqueueUnmapMemObject_definition,
    &clEnqueueWaitForEvents_definition,
    &clEnqueueWriteBuffer_definition,
    &clEnqueueWriteBufferRect_definition,
    &clEnqueueWriteImage_definition,
    &clFinish_definition,
    &clFlush_definition,
    &clGetCommandQueueInfo_definition,
    &clGetContextInfo_definition,
    &clGetDeviceIDs_definition,
    &clGetDeviceInfo_definition,
    &clGetEventInfo_definition,
    &clGetEventProfilingInfo_definition,
    &clGetExtensionFunctionAddress_definition,
    &clGetExtensionFunctionAddressForPlatform_definition,
    &clGetImageInfo_definition,
    &clGetKernelArgInfo_definition,
    &clGetKernelInfo_definition,
    &clGetKernelWorkGroupInfo_definition,
    &clGetMemObjectInfo_definition,
    &clGetPlatformIDs_definition,
    &clGetPlatformInfo_definition,
    &clGetProgramBuildInfo_definition,
    &clGetProgramInfo_definition,
    &clGetSamplerInfo_definition,
    &clGetSupportedImageFormats_definition,
    &clLinkProgram_definition,
    &clReleaseCommandQueue_definition,
    &clReleaseContext_definition,
    &clReleaseDevice_definition,
    &clReleaseEvent_definition,
    &clReleaseKernel_definition,
    &clReleaseMemObject_definition,
    &clReleaseProgram_definition,
    &clReleaseSampler_definition,
    &clRetainCommandQueue_definition,
    &clRetainContext_definition,
    &clRetainDevice_definition,
    &clRetainEvent_definition,
    &clRetainKernel_definition,
    &clRetainMemObject_definition,
    &clRetainProgram_definition,
    &clRetainSampler_definition,
    &clSetEventCallback_definition,
    &clSetKernelArg_definition,
    &clSetMemObjectDestructorCallback_definition,
    &clSetUserEventStatus_definition,
    &clUnloadCompiler_definition,
    &clUnloadPlatformCompiler_definition,
    &clWaitForEvents_definition,
};

// number of enabled functions: 88
