clwrap.cpp

#include <CL/cl.h>
#include <dlfcn.h>
#include <type_traits>

namespace weakbindgen {
    template<typname T> using id = T;
}
using namespace weakbindgen;

namespace weakbindgen {
static void *module_handle;
bool const OpenCL_available = [] {
    module_handle = ::dlopen("OpenCL", RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);
    return module_handle;
}();
}
cl_int clGetPlatformIDs(cl_uint p0, cl_platform_id * p1, cl_uint * p2) {
 static auto const fptr = reinterpret_cast<decltype(clGetPlatformIDs) *>(::dlsym(module_handle, "clGetPlatformIDs"));
 return fptr(p0, p1, p2);
}
cl_int clGetPlatformInfo(cl_platform_id p0, cl_platform_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetPlatformInfo) *>(::dlsym(module_handle, "clGetPlatformInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clGetDeviceIDs(cl_platform_id p0, cl_device_type p1, cl_uint p2, cl_device_id * p3, cl_uint * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetDeviceIDs) *>(::dlsym(module_handle, "clGetDeviceIDs"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clGetDeviceInfo(cl_device_id p0, cl_device_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetDeviceInfo) *>(::dlsym(module_handle, "clGetDeviceInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clCreateSubDevices(cl_device_id p0, const cl_device_partition_property * p1, cl_uint p2, cl_device_id * p3, cl_uint * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateSubDevices) *>(::dlsym(module_handle, "clCreateSubDevices"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clRetainDevice(cl_device_id p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainDevice) *>(::dlsym(module_handle, "clRetainDevice"));
 return fptr(p0);
}
cl_int clReleaseDevice(cl_device_id p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseDevice) *>(::dlsym(module_handle, "clReleaseDevice"));
 return fptr(p0);
}
cl_int clSetDefaultDeviceCommandQueue(cl_context p0, cl_device_id p1, cl_command_queue p2) {
 static auto const fptr = reinterpret_cast<decltype(clSetDefaultDeviceCommandQueue) *>(::dlsym(module_handle, "clSetDefaultDeviceCommandQueue"));
 return fptr(p0, p1, p2);
}
cl_int clGetDeviceAndHostTimer(cl_device_id p0, cl_ulong * p1, cl_ulong * p2) {
 static auto const fptr = reinterpret_cast<decltype(clGetDeviceAndHostTimer) *>(::dlsym(module_handle, "clGetDeviceAndHostTimer"));
 return fptr(p0, p1, p2);
}
cl_int clGetHostTimer(cl_device_id p0, cl_ulong * p1) {
 static auto const fptr = reinterpret_cast<decltype(clGetHostTimer) *>(::dlsym(module_handle, "clGetHostTimer"));
 return fptr(p0, p1);
}
cl_context clCreateContext(const cl_context_properties * p0, cl_uint p1, const cl_device_id * p2, id<void (*)(const char *, const void *, size_t, void *)> p3, void * p4, cl_int * p5) {
 static auto const fptr = reinterpret_cast<decltype(clCreateContext) *>(::dlsym(module_handle, "clCreateContext"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_context clCreateContextFromType(const cl_context_properties * p0, cl_device_type p1, id<void (*)(const char *, const void *, size_t, void *)> p2, void * p3, cl_int * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateContextFromType) *>(::dlsym(module_handle, "clCreateContextFromType"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clRetainContext(cl_context p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainContext) *>(::dlsym(module_handle, "clRetainContext"));
 return fptr(p0);
}
cl_int clReleaseContext(cl_context p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseContext) *>(::dlsym(module_handle, "clReleaseContext"));
 return fptr(p0);
}
cl_int clGetContextInfo(cl_context p0, cl_context_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetContextInfo) *>(::dlsym(module_handle, "clGetContextInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_command_queue clCreateCommandQueueWithProperties(cl_context p0, cl_device_id p1, const cl_queue_properties * p2, cl_int * p3) {
 static auto const fptr = reinterpret_cast<decltype(clCreateCommandQueueWithProperties) *>(::dlsym(module_handle, "clCreateCommandQueueWithProperties"));
 return fptr(p0, p1, p2, p3);
}
cl_int clRetainCommandQueue(cl_command_queue p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainCommandQueue) *>(::dlsym(module_handle, "clRetainCommandQueue"));
 return fptr(p0);
}
cl_int clReleaseCommandQueue(cl_command_queue p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseCommandQueue) *>(::dlsym(module_handle, "clReleaseCommandQueue"));
 return fptr(p0);
}
cl_int clGetCommandQueueInfo(cl_command_queue p0, cl_command_queue_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetCommandQueueInfo) *>(::dlsym(module_handle, "clGetCommandQueueInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_mem clCreateBuffer(cl_context p0, cl_mem_flags p1, size_t p2, void * p3, cl_int * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateBuffer) *>(::dlsym(module_handle, "clCreateBuffer"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_mem clCreateSubBuffer(cl_mem p0, cl_mem_flags p1, cl_buffer_create_type p2, const void * p3, cl_int * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateSubBuffer) *>(::dlsym(module_handle, "clCreateSubBuffer"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_mem clCreateImage(cl_context p0, cl_mem_flags p1, const cl_image_format * p2, const cl_image_desc * p3, void * p4, cl_int * p5) {
 static auto const fptr = reinterpret_cast<decltype(clCreateImage) *>(::dlsym(module_handle, "clCreateImage"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_mem clCreatePipe(cl_context p0, cl_mem_flags p1, cl_uint p2, cl_uint p3, const cl_pipe_properties * p4, cl_int * p5) {
 static auto const fptr = reinterpret_cast<decltype(clCreatePipe) *>(::dlsym(module_handle, "clCreatePipe"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_int clRetainMemObject(cl_mem p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainMemObject) *>(::dlsym(module_handle, "clRetainMemObject"));
 return fptr(p0);
}
cl_int clReleaseMemObject(cl_mem p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseMemObject) *>(::dlsym(module_handle, "clReleaseMemObject"));
 return fptr(p0);
}
cl_int clGetSupportedImageFormats(cl_context p0, cl_mem_flags p1, cl_mem_object_type p2, cl_uint p3, cl_image_format * p4, cl_uint * p5) {
 static auto const fptr = reinterpret_cast<decltype(clGetSupportedImageFormats) *>(::dlsym(module_handle, "clGetSupportedImageFormats"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_int clGetMemObjectInfo(cl_mem p0, cl_mem_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetMemObjectInfo) *>(::dlsym(module_handle, "clGetMemObjectInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clGetImageInfo(cl_mem p0, cl_image_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetImageInfo) *>(::dlsym(module_handle, "clGetImageInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clGetPipeInfo(cl_mem p0, cl_pipe_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetPipeInfo) *>(::dlsym(module_handle, "clGetPipeInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clSetMemObjectDestructorCallback(cl_mem p0, id<void (*)(cl_mem, void *)> p1, void * p2) {
 static auto const fptr = reinterpret_cast<decltype(clSetMemObjectDestructorCallback) *>(::dlsym(module_handle, "clSetMemObjectDestructorCallback"));
 return fptr(p0, p1, p2);
}
void * clSVMAlloc(cl_context p0, cl_svm_mem_flags p1, size_t p2, cl_uint p3) {
 static auto const fptr = reinterpret_cast<decltype(clSVMAlloc) *>(::dlsym(module_handle, "clSVMAlloc"));
 return fptr(p0, p1, p2, p3);
}
void clSVMFree(cl_context p0, void * p1) {
 static auto const fptr = reinterpret_cast<decltype(clSVMFree) *>(::dlsym(module_handle, "clSVMFree"));
 return fptr(p0, p1);
}
cl_sampler clCreateSamplerWithProperties(cl_context p0, const cl_sampler_properties * p1, cl_int * p2) {
 static auto const fptr = reinterpret_cast<decltype(clCreateSamplerWithProperties) *>(::dlsym(module_handle, "clCreateSamplerWithProperties"));
 return fptr(p0, p1, p2);
}
cl_int clRetainSampler(cl_sampler p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainSampler) *>(::dlsym(module_handle, "clRetainSampler"));
 return fptr(p0);
}
cl_int clReleaseSampler(cl_sampler p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseSampler) *>(::dlsym(module_handle, "clReleaseSampler"));
 return fptr(p0);
}
cl_int clGetSamplerInfo(cl_sampler p0, cl_sampler_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetSamplerInfo) *>(::dlsym(module_handle, "clGetSamplerInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_program clCreateProgramWithSource(cl_context p0, cl_uint p1, const char ** p2, const size_t * p3, cl_int * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateProgramWithSource) *>(::dlsym(module_handle, "clCreateProgramWithSource"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_program clCreateProgramWithBinary(cl_context p0, cl_uint p1, const cl_device_id * p2, const size_t * p3, const unsigned char ** p4, cl_int * p5, cl_int * p6) {
 static auto const fptr = reinterpret_cast<decltype(clCreateProgramWithBinary) *>(::dlsym(module_handle, "clCreateProgramWithBinary"));
 return fptr(p0, p1, p2, p3, p4, p5, p6);
}
cl_program clCreateProgramWithBuiltInKernels(cl_context p0, cl_uint p1, const cl_device_id * p2, const char * p3, cl_int * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateProgramWithBuiltInKernels) *>(::dlsym(module_handle, "clCreateProgramWithBuiltInKernels"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_program clCreateProgramWithIL(cl_context p0, const void * p1, size_t p2, cl_int * p3) {
 static auto const fptr = reinterpret_cast<decltype(clCreateProgramWithIL) *>(::dlsym(module_handle, "clCreateProgramWithIL"));
 return fptr(p0, p1, p2, p3);
}
cl_int clRetainProgram(cl_program p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainProgram) *>(::dlsym(module_handle, "clRetainProgram"));
 return fptr(p0);
}
cl_int clReleaseProgram(cl_program p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseProgram) *>(::dlsym(module_handle, "clReleaseProgram"));
 return fptr(p0);
}
cl_int clBuildProgram(cl_program p0, cl_uint p1, const cl_device_id * p2, const char * p3, id<void (*)(cl_program, void *)> p4, void * p5) {
 static auto const fptr = reinterpret_cast<decltype(clBuildProgram) *>(::dlsym(module_handle, "clBuildProgram"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_int clCompileProgram(cl_program p0, cl_uint p1, const cl_device_id * p2, const char * p3, cl_uint p4, const cl_program * p5, const char ** p6, id<void (*)(cl_program, void *)> p7, void * p8) {
 static auto const fptr = reinterpret_cast<decltype(clCompileProgram) *>(::dlsym(module_handle, "clCompileProgram"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_program clLinkProgram(cl_context p0, cl_uint p1, const cl_device_id * p2, const char * p3, cl_uint p4, const cl_program * p5, id<void (*)(cl_program, void *)> p6, void * p7, cl_int * p8) {
 static auto const fptr = reinterpret_cast<decltype(clLinkProgram) *>(::dlsym(module_handle, "clLinkProgram"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clSetProgramReleaseCallback(cl_program p0, id<void (*)(cl_program, void *)> p1, void * p2) {
 static auto const fptr = reinterpret_cast<decltype(clSetProgramReleaseCallback) *>(::dlsym(module_handle, "clSetProgramReleaseCallback"));
 return fptr(p0, p1, p2);
}
cl_int clSetProgramSpecializationConstant(cl_program p0, cl_uint p1, size_t p2, const void * p3) {
 static auto const fptr = reinterpret_cast<decltype(clSetProgramSpecializationConstant) *>(::dlsym(module_handle, "clSetProgramSpecializationConstant"));
 return fptr(p0, p1, p2, p3);
}
cl_int clUnloadPlatformCompiler(cl_platform_id p0) {
 static auto const fptr = reinterpret_cast<decltype(clUnloadPlatformCompiler) *>(::dlsym(module_handle, "clUnloadPlatformCompiler"));
 return fptr(p0);
}
cl_int clGetProgramInfo(cl_program p0, cl_program_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetProgramInfo) *>(::dlsym(module_handle, "clGetProgramInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clGetProgramBuildInfo(cl_program p0, cl_device_id p1, cl_program_build_info p2, size_t p3, void * p4, size_t * p5) {
 static auto const fptr = reinterpret_cast<decltype(clGetProgramBuildInfo) *>(::dlsym(module_handle, "clGetProgramBuildInfo"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_kernel clCreateKernel(cl_program p0, const char * p1, cl_int * p2) {
 static auto const fptr = reinterpret_cast<decltype(clCreateKernel) *>(::dlsym(module_handle, "clCreateKernel"));
 return fptr(p0, p1, p2);
}
cl_int clCreateKernelsInProgram(cl_program p0, cl_uint p1, cl_kernel * p2, cl_uint * p3) {
 static auto const fptr = reinterpret_cast<decltype(clCreateKernelsInProgram) *>(::dlsym(module_handle, "clCreateKernelsInProgram"));
 return fptr(p0, p1, p2, p3);
}
cl_kernel clCloneKernel(cl_kernel p0, cl_int * p1) {
 static auto const fptr = reinterpret_cast<decltype(clCloneKernel) *>(::dlsym(module_handle, "clCloneKernel"));
 return fptr(p0, p1);
}
cl_int clRetainKernel(cl_kernel p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainKernel) *>(::dlsym(module_handle, "clRetainKernel"));
 return fptr(p0);
}
cl_int clReleaseKernel(cl_kernel p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseKernel) *>(::dlsym(module_handle, "clReleaseKernel"));
 return fptr(p0);
}
cl_int clSetKernelArg(cl_kernel p0, cl_uint p1, size_t p2, const void * p3) {
 static auto const fptr = reinterpret_cast<decltype(clSetKernelArg) *>(::dlsym(module_handle, "clSetKernelArg"));
 return fptr(p0, p1, p2, p3);
}
cl_int clSetKernelArgSVMPointer(cl_kernel p0, cl_uint p1, const void * p2) {
 static auto const fptr = reinterpret_cast<decltype(clSetKernelArgSVMPointer) *>(::dlsym(module_handle, "clSetKernelArgSVMPointer"));
 return fptr(p0, p1, p2);
}
cl_int clSetKernelExecInfo(cl_kernel p0, cl_kernel_exec_info p1, size_t p2, const void * p3) {
 static auto const fptr = reinterpret_cast<decltype(clSetKernelExecInfo) *>(::dlsym(module_handle, "clSetKernelExecInfo"));
 return fptr(p0, p1, p2, p3);
}
cl_int clGetKernelInfo(cl_kernel p0, cl_kernel_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetKernelInfo) *>(::dlsym(module_handle, "clGetKernelInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clGetKernelArgInfo(cl_kernel p0, cl_uint p1, cl_kernel_arg_info p2, size_t p3, void * p4, size_t * p5) {
 static auto const fptr = reinterpret_cast<decltype(clGetKernelArgInfo) *>(::dlsym(module_handle, "clGetKernelArgInfo"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_int clGetKernelWorkGroupInfo(cl_kernel p0, cl_device_id p1, cl_kernel_work_group_info p2, size_t p3, void * p4, size_t * p5) {
 static auto const fptr = reinterpret_cast<decltype(clGetKernelWorkGroupInfo) *>(::dlsym(module_handle, "clGetKernelWorkGroupInfo"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_int clGetKernelSubGroupInfo(cl_kernel p0, cl_device_id p1, cl_kernel_sub_group_info p2, size_t p3, const void * p4, size_t p5, void * p6, size_t * p7) {
 static auto const fptr = reinterpret_cast<decltype(clGetKernelSubGroupInfo) *>(::dlsym(module_handle, "clGetKernelSubGroupInfo"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_int clWaitForEvents(cl_uint p0, const cl_event * p1) {
 static auto const fptr = reinterpret_cast<decltype(clWaitForEvents) *>(::dlsym(module_handle, "clWaitForEvents"));
 return fptr(p0, p1);
}
cl_int clGetEventInfo(cl_event p0, cl_event_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetEventInfo) *>(::dlsym(module_handle, "clGetEventInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_event clCreateUserEvent(cl_context p0, cl_int * p1) {
 static auto const fptr = reinterpret_cast<decltype(clCreateUserEvent) *>(::dlsym(module_handle, "clCreateUserEvent"));
 return fptr(p0, p1);
}
cl_int clRetainEvent(cl_event p0) {
 static auto const fptr = reinterpret_cast<decltype(clRetainEvent) *>(::dlsym(module_handle, "clRetainEvent"));
 return fptr(p0);
}
cl_int clReleaseEvent(cl_event p0) {
 static auto const fptr = reinterpret_cast<decltype(clReleaseEvent) *>(::dlsym(module_handle, "clReleaseEvent"));
 return fptr(p0);
}
cl_int clSetUserEventStatus(cl_event p0, cl_int p1) {
 static auto const fptr = reinterpret_cast<decltype(clSetUserEventStatus) *>(::dlsym(module_handle, "clSetUserEventStatus"));
 return fptr(p0, p1);
}
cl_int clSetEventCallback(cl_event p0, cl_int p1, id<void (*)(cl_event, cl_int, void *)> p2, void * p3) {
 static auto const fptr = reinterpret_cast<decltype(clSetEventCallback) *>(::dlsym(module_handle, "clSetEventCallback"));
 return fptr(p0, p1, p2, p3);
}
cl_int clGetEventProfilingInfo(cl_event p0, cl_profiling_info p1, size_t p2, void * p3, size_t * p4) {
 static auto const fptr = reinterpret_cast<decltype(clGetEventProfilingInfo) *>(::dlsym(module_handle, "clGetEventProfilingInfo"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clFlush(cl_command_queue p0) {
 static auto const fptr = reinterpret_cast<decltype(clFlush) *>(::dlsym(module_handle, "clFlush"));
 return fptr(p0);
}
cl_int clFinish(cl_command_queue p0) {
 static auto const fptr = reinterpret_cast<decltype(clFinish) *>(::dlsym(module_handle, "clFinish"));
 return fptr(p0);
}
cl_int clEnqueueReadBuffer(cl_command_queue p0, cl_mem p1, cl_bool p2, size_t p3, size_t p4, void * p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueReadBuffer) *>(::dlsym(module_handle, "clEnqueueReadBuffer"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueReadBufferRect(cl_command_queue p0, cl_mem p1, cl_bool p2, const size_t * p3, const size_t * p4, const size_t * p5, size_t p6, size_t p7, size_t p8, size_t p9, void * p10, cl_uint p11, const cl_event * p12, cl_event * p13) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueReadBufferRect) *>(::dlsym(module_handle, "clEnqueueReadBufferRect"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
}
cl_int clEnqueueWriteBuffer(cl_command_queue p0, cl_mem p1, cl_bool p2, size_t p3, size_t p4, const void * p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueWriteBuffer) *>(::dlsym(module_handle, "clEnqueueWriteBuffer"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueWriteBufferRect(cl_command_queue p0, cl_mem p1, cl_bool p2, const size_t * p3, const size_t * p4, const size_t * p5, size_t p6, size_t p7, size_t p8, size_t p9, const void * p10, cl_uint p11, const cl_event * p12, cl_event * p13) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueWriteBufferRect) *>(::dlsym(module_handle, "clEnqueueWriteBufferRect"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
}
cl_int clEnqueueFillBuffer(cl_command_queue p0, cl_mem p1, const void * p2, size_t p3, size_t p4, size_t p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueFillBuffer) *>(::dlsym(module_handle, "clEnqueueFillBuffer"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueCopyBuffer(cl_command_queue p0, cl_mem p1, cl_mem p2, size_t p3, size_t p4, size_t p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueCopyBuffer) *>(::dlsym(module_handle, "clEnqueueCopyBuffer"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueCopyBufferRect(cl_command_queue p0, cl_mem p1, cl_mem p2, const size_t * p3, const size_t * p4, const size_t * p5, size_t p6, size_t p7, size_t p8, size_t p9, cl_uint p10, const cl_event * p11, cl_event * p12) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueCopyBufferRect) *>(::dlsym(module_handle, "clEnqueueCopyBufferRect"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
}
cl_int clEnqueueReadImage(cl_command_queue p0, cl_mem p1, cl_bool p2, const size_t * p3, const size_t * p4, size_t p5, size_t p6, void * p7, cl_uint p8, const cl_event * p9, cl_event * p10) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueReadImage) *>(::dlsym(module_handle, "clEnqueueReadImage"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
}
cl_int clEnqueueWriteImage(cl_command_queue p0, cl_mem p1, cl_bool p2, const size_t * p3, const size_t * p4, size_t p5, size_t p6, const void * p7, cl_uint p8, const cl_event * p9, cl_event * p10) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueWriteImage) *>(::dlsym(module_handle, "clEnqueueWriteImage"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
}
cl_int clEnqueueFillImage(cl_command_queue p0, cl_mem p1, const void * p2, const size_t * p3, const size_t * p4, cl_uint p5, const cl_event * p6, cl_event * p7) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueFillImage) *>(::dlsym(module_handle, "clEnqueueFillImage"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_int clEnqueueCopyImage(cl_command_queue p0, cl_mem p1, cl_mem p2, const size_t * p3, const size_t * p4, const size_t * p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueCopyImage) *>(::dlsym(module_handle, "clEnqueueCopyImage"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueCopyImageToBuffer(cl_command_queue p0, cl_mem p1, cl_mem p2, const size_t * p3, const size_t * p4, size_t p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueCopyImageToBuffer) *>(::dlsym(module_handle, "clEnqueueCopyImageToBuffer"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueCopyBufferToImage(cl_command_queue p0, cl_mem p1, cl_mem p2, size_t p3, const size_t * p4, const size_t * p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueCopyBufferToImage) *>(::dlsym(module_handle, "clEnqueueCopyBufferToImage"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
void * clEnqueueMapBuffer(cl_command_queue p0, cl_mem p1, cl_bool p2, cl_map_flags p3, size_t p4, size_t p5, cl_uint p6, const cl_event * p7, cl_event * p8, cl_int * p9) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueMapBuffer) *>(::dlsym(module_handle, "clEnqueueMapBuffer"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}
void * clEnqueueMapImage(cl_command_queue p0, cl_mem p1, cl_bool p2, cl_map_flags p3, const size_t * p4, const size_t * p5, size_t * p6, size_t * p7, cl_uint p8, const cl_event * p9, cl_event * p10, cl_int * p11) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueMapImage) *>(::dlsym(module_handle, "clEnqueueMapImage"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
}
cl_int clEnqueueUnmapMemObject(cl_command_queue p0, cl_mem p1, void * p2, cl_uint p3, const cl_event * p4, cl_event * p5) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueUnmapMemObject) *>(::dlsym(module_handle, "clEnqueueUnmapMemObject"));
 return fptr(p0, p1, p2, p3, p4, p5);
}
cl_int clEnqueueMigrateMemObjects(cl_command_queue p0, cl_uint p1, const cl_mem * p2, cl_mem_migration_flags p3, cl_uint p4, const cl_event * p5, cl_event * p6) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueMigrateMemObjects) *>(::dlsym(module_handle, "clEnqueueMigrateMemObjects"));
 return fptr(p0, p1, p2, p3, p4, p5, p6);
}
cl_int clEnqueueNDRangeKernel(cl_command_queue p0, cl_kernel p1, cl_uint p2, const size_t * p3, const size_t * p4, const size_t * p5, cl_uint p6, const cl_event * p7, cl_event * p8) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueNDRangeKernel) *>(::dlsym(module_handle, "clEnqueueNDRangeKernel"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
cl_int clEnqueueNativeKernel(cl_command_queue p0, id<void (*)(void *)> p1, void * p2, size_t p3, cl_uint p4, const cl_mem * p5, const void ** p6, cl_uint p7, const cl_event * p8, cl_event * p9) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueNativeKernel) *>(::dlsym(module_handle, "clEnqueueNativeKernel"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}
cl_int clEnqueueMarkerWithWaitList(cl_command_queue p0, cl_uint p1, const cl_event * p2, cl_event * p3) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueMarkerWithWaitList) *>(::dlsym(module_handle, "clEnqueueMarkerWithWaitList"));
 return fptr(p0, p1, p2, p3);
}
cl_int clEnqueueBarrierWithWaitList(cl_command_queue p0, cl_uint p1, const cl_event * p2, cl_event * p3) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueBarrierWithWaitList) *>(::dlsym(module_handle, "clEnqueueBarrierWithWaitList"));
 return fptr(p0, p1, p2, p3);
}
cl_int clEnqueueSVMFree(cl_command_queue p0, cl_uint p1, void ** p2, id<void (*)(cl_command_queue, cl_uint, void **, void *)> p3, void * p4, cl_uint p5, const cl_event * p6, cl_event * p7) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueSVMFree) *>(::dlsym(module_handle, "clEnqueueSVMFree"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_int clEnqueueSVMMemcpy(cl_command_queue p0, cl_bool p1, void * p2, const void * p3, size_t p4, cl_uint p5, const cl_event * p6, cl_event * p7) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueSVMMemcpy) *>(::dlsym(module_handle, "clEnqueueSVMMemcpy"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_int clEnqueueSVMMemFill(cl_command_queue p0, void * p1, const void * p2, size_t p3, size_t p4, cl_uint p5, const cl_event * p6, cl_event * p7) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueSVMMemFill) *>(::dlsym(module_handle, "clEnqueueSVMMemFill"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_int clEnqueueSVMMap(cl_command_queue p0, cl_bool p1, cl_map_flags p2, void * p3, size_t p4, cl_uint p5, const cl_event * p6, cl_event * p7) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueSVMMap) *>(::dlsym(module_handle, "clEnqueueSVMMap"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_int clEnqueueSVMUnmap(cl_command_queue p0, void * p1, cl_uint p2, const cl_event * p3, cl_event * p4) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueSVMUnmap) *>(::dlsym(module_handle, "clEnqueueSVMUnmap"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clEnqueueSVMMigrateMem(cl_command_queue p0, cl_uint p1, const void ** p2, const size_t * p3, cl_mem_migration_flags p4, cl_uint p5, const cl_event * p6, cl_event * p7) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueSVMMigrateMem) *>(::dlsym(module_handle, "clEnqueueSVMMigrateMem"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
void * clGetExtensionFunctionAddressForPlatform(cl_platform_id p0, const char * p1) {
 static auto const fptr = reinterpret_cast<decltype(clGetExtensionFunctionAddressForPlatform) *>(::dlsym(module_handle, "clGetExtensionFunctionAddressForPlatform"));
 return fptr(p0, p1);
}
cl_mem clCreateImage2D(cl_context p0, cl_mem_flags p1, const cl_image_format * p2, size_t p3, size_t p4, size_t p5, void * p6, cl_int * p7) {
 static auto const fptr = reinterpret_cast<decltype(clCreateImage2D) *>(::dlsym(module_handle, "clCreateImage2D"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7);
}
cl_mem clCreateImage3D(cl_context p0, cl_mem_flags p1, const cl_image_format * p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7, void * p8, cl_int * p9) {
 static auto const fptr = reinterpret_cast<decltype(clCreateImage3D) *>(::dlsym(module_handle, "clCreateImage3D"));
 return fptr(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}
cl_int clEnqueueMarker(cl_command_queue p0, cl_event * p1) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueMarker) *>(::dlsym(module_handle, "clEnqueueMarker"));
 return fptr(p0, p1);
}
cl_int clEnqueueWaitForEvents(cl_command_queue p0, cl_uint p1, const cl_event * p2) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueWaitForEvents) *>(::dlsym(module_handle, "clEnqueueWaitForEvents"));
 return fptr(p0, p1, p2);
}
cl_int clEnqueueBarrier(cl_command_queue p0) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueBarrier) *>(::dlsym(module_handle, "clEnqueueBarrier"));
 return fptr(p0);
}
cl_int clUnloadCompiler() {
 static auto const fptr = reinterpret_cast<decltype(clUnloadCompiler) *>(::dlsym(module_handle, "clUnloadCompiler"));
 return fptr();
}
void * clGetExtensionFunctionAddress(const char * p0) {
 static auto const fptr = reinterpret_cast<decltype(clGetExtensionFunctionAddress) *>(::dlsym(module_handle, "clGetExtensionFunctionAddress"));
 return fptr(p0);
}
cl_command_queue clCreateCommandQueue(cl_context p0, cl_device_id p1, cl_command_queue_properties p2, cl_int * p3) {
 static auto const fptr = reinterpret_cast<decltype(clCreateCommandQueue) *>(::dlsym(module_handle, "clCreateCommandQueue"));
 return fptr(p0, p1, p2, p3);
}
cl_sampler clCreateSampler(cl_context p0, cl_bool p1, cl_addressing_mode p2, cl_filter_mode p3, cl_int * p4) {
 static auto const fptr = reinterpret_cast<decltype(clCreateSampler) *>(::dlsym(module_handle, "clCreateSampler"));
 return fptr(p0, p1, p2, p3, p4);
}
cl_int clEnqueueTask(cl_command_queue p0, cl_kernel p1, cl_uint p2, const cl_event * p3, cl_event * p4) {
 static auto const fptr = reinterpret_cast<decltype(clEnqueueTask) *>(::dlsym(module_handle, "clEnqueueTask"));
 return fptr(p0, p1, p2, p3, p4);
}