exo/tinychat/tinygrad/runtime/autogen/opencl.py

# mypy: ignore-errors
# -*- coding: utf-8 -*-
#
# TARGET arch is: []
# WORD_SIZE is: 8
# POINTER_SIZE is: 8
# LONGDOUBLE_SIZE is: 16
#
import ctypes, ctypes.util


class AsDictMixin:
    @classmethod
    def as_dict(cls, self):
        result = {}
        if not isinstance(self, AsDictMixin):
            # not a structure, assume it's already a python object
            return self
        if not hasattr(cls, "_fields_"):
            return result
        # sys.version_info >= (3, 5)
        # for (field, *_) in cls._fields_:  # noqa
        for field_tuple in cls._fields_:  # noqa
            field = field_tuple[0]
            if field.startswith('PADDING_'):
                continue
            value = getattr(self, field)
            type_ = type(value)
            if hasattr(value, "_length_") and hasattr(value, "_type_"):
                # array
                if not hasattr(type_, "as_dict"):
                    value = [v for v in value]
                else:
                    type_ = type_._type_
                    value = [type_.as_dict(v) for v in value]
            elif hasattr(value, "contents") and hasattr(value, "_type_"):
                # pointer
                try:
                    if not hasattr(type_, "as_dict"):
                        value = value.contents
                    else:
                        type_ = type_._type_
                        value = type_.as_dict(value.contents)
                except ValueError:
                    # nullptr
                    value = None
            elif isinstance(value, AsDictMixin):
                # other structure
                value = type_.as_dict(value)
            result[field] = value
        return result


class Structure(ctypes.Structure, AsDictMixin):

    def __init__(self, *args, **kwds):
        # We don't want to use positional arguments fill PADDING_* fields

        args = dict(zip(self.__class__._field_names_(), args))
        args.update(kwds)
        super(Structure, self).__init__(**args)

    @classmethod
    def _field_names_(cls):
        if hasattr(cls, '_fields_'):
            return (f[0] for f in cls._fields_ if not f[0].startswith('PADDING'))
        else:
            return ()

    @classmethod
    def get_type(cls, field):
        for f in cls._fields_:
            if f[0] == field:
                return f[1]
        return None

    @classmethod
    def bind(cls, bound_fields):
        fields = {}
        for name, type_ in cls._fields_:
            if hasattr(type_, "restype"):
                if name in bound_fields:
                    if bound_fields[name] is None:
                        fields[name] = type_()
                    else:
                        # use a closure to capture the callback from the loop scope
                        fields[name] = (
                            type_((lambda callback: lambda *args: callback(*args))(
                                bound_fields[name]))
                        )
                    del bound_fields[name]
                else:
                    # default callback implementation (does nothing)
                    try:
                        default_ = type_(0).restype().value
                    except TypeError:
                        default_ = None
                    fields[name] = type_((
                        lambda default_: lambda *args: default_)(default_))
            else:
                # not a callback function, use default initialization
                if name in bound_fields:
                    fields[name] = bound_fields[name]
                    del bound_fields[name]
                else:
                    fields[name] = type_()
        if len(bound_fields) != 0:
            raise ValueError(
                "Cannot bind the following unknown callback(s) {}.{}".format(
                    cls.__name__, bound_fields.keys()
            ))
        return cls(**fields)


class Union(ctypes.Union, AsDictMixin):
    pass



_libraries = {}
_libraries['libOpenCL.so.1'] = ctypes.CDLL(ctypes.util.find_library('OpenCL'))
c_int128 = ctypes.c_ubyte*16
c_uint128 = c_int128
void = None
if ctypes.sizeof(ctypes.c_longdouble) == 16:
    c_long_double_t = ctypes.c_longdouble
else:
    c_long_double_t = ctypes.c_ubyte*16

def string_cast(char_pointer, encoding='utf-8', errors='strict'):
    value = ctypes.cast(char_pointer, ctypes.c_char_p).value
    if value is not None and encoding is not None:
        value = value.decode(encoding, errors=errors)
    return value


def char_pointer_cast(string, encoding='utf-8'):
    if encoding is not None:
        try:
            string = string.encode(encoding)
        except AttributeError:
            # In Python3, bytes has no encode attribute
            pass
    string = ctypes.c_char_p(string)
    return ctypes.cast(string, ctypes.POINTER(ctypes.c_char))





__OPENCL_CL_H = True # macro
CL_NAME_VERSION_MAX_NAME_SIZE = 64 # macro
CL_SUCCESS = 0 # macro
CL_DEVICE_NOT_FOUND = -1 # macro
CL_DEVICE_NOT_AVAILABLE = -2 # macro
CL_COMPILER_NOT_AVAILABLE = -3 # macro
CL_MEM_OBJECT_ALLOCATION_FAILURE = -4 # macro
CL_OUT_OF_RESOURCES = -5 # macro
CL_OUT_OF_HOST_MEMORY = -6 # macro
CL_PROFILING_INFO_NOT_AVAILABLE = -7 # macro
CL_MEM_COPY_OVERLAP = -8 # macro
CL_IMAGE_FORMAT_MISMATCH = -9 # macro
CL_IMAGE_FORMAT_NOT_SUPPORTED = -10 # macro
CL_BUILD_PROGRAM_FAILURE = -11 # macro
CL_MAP_FAILURE = -12 # macro
CL_MISALIGNED_SUB_BUFFER_OFFSET = -13 # macro
CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST = -14 # macro
CL_COMPILE_PROGRAM_FAILURE = -15 # macro
CL_LINKER_NOT_AVAILABLE = -16 # macro
CL_LINK_PROGRAM_FAILURE = -17 # macro
CL_DEVICE_PARTITION_FAILED = -18 # macro
CL_KERNEL_ARG_INFO_NOT_AVAILABLE = -19 # macro
CL_INVALID_VALUE = -30 # macro
CL_INVALID_DEVICE_TYPE = -31 # macro
CL_INVALID_PLATFORM = -32 # macro
CL_INVALID_DEVICE = -33 # macro
CL_INVALID_CONTEXT = -34 # macro
CL_INVALID_QUEUE_PROPERTIES = -35 # macro
CL_INVALID_COMMAND_QUEUE = -36 # macro
CL_INVALID_HOST_PTR = -37 # macro
CL_INVALID_MEM_OBJECT = -38 # macro
CL_INVALID_IMAGE_FORMAT_DESCRIPTOR = -39 # macro
CL_INVALID_IMAGE_SIZE = -40 # macro
CL_INVALID_SAMPLER = -41 # macro
CL_INVALID_BINARY = -42 # macro
CL_INVALID_BUILD_OPTIONS = -43 # macro
CL_INVALID_PROGRAM = -44 # macro
CL_INVALID_PROGRAM_EXECUTABLE = -45 # macro
CL_INVALID_KERNEL_NAME = -46 # macro
CL_INVALID_KERNEL_DEFINITION = -47 # macro
CL_INVALID_KERNEL = -48 # macro
CL_INVALID_ARG_INDEX = -49 # macro
CL_INVALID_ARG_VALUE = -50 # macro
CL_INVALID_ARG_SIZE = -51 # macro
CL_INVALID_KERNEL_ARGS = -52 # macro
CL_INVALID_WORK_DIMENSION = -53 # macro
CL_INVALID_WORK_GROUP_SIZE = -54 # macro
CL_INVALID_WORK_ITEM_SIZE = -55 # macro
CL_INVALID_GLOBAL_OFFSET = -56 # macro
CL_INVALID_EVENT_WAIT_LIST = -57 # macro
CL_INVALID_EVENT = -58 # macro
CL_INVALID_OPERATION = -59 # macro
CL_INVALID_GL_OBJECT = -60 # macro
CL_INVALID_BUFFER_SIZE = -61 # macro
CL_INVALID_MIP_LEVEL = -62 # macro
CL_INVALID_GLOBAL_WORK_SIZE = -63 # macro
CL_INVALID_PROPERTY = -64 # macro
CL_INVALID_IMAGE_DESCRIPTOR = -65 # macro
CL_INVALID_COMPILER_OPTIONS = -66 # macro
CL_INVALID_LINKER_OPTIONS = -67 # macro
CL_INVALID_DEVICE_PARTITION_COUNT = -68 # macro
CL_INVALID_PIPE_SIZE = -69 # macro
CL_INVALID_DEVICE_QUEUE = -70 # macro
CL_INVALID_SPEC_ID = -71 # macro
CL_MAX_SIZE_RESTRICTION_EXCEEDED = -72 # macro
CL_FALSE = 0 # macro
CL_TRUE = 1 # macro
CL_BLOCKING = 1 # macro
CL_NON_BLOCKING = 0 # macro
CL_PLATFORM_PROFILE = 0x0900 # macro
CL_PLATFORM_VERSION = 0x0901 # macro
CL_PLATFORM_NAME = 0x0902 # macro
CL_PLATFORM_VENDOR = 0x0903 # macro
CL_PLATFORM_EXTENSIONS = 0x0904 # macro
CL_PLATFORM_HOST_TIMER_RESOLUTION = 0x0905 # macro
CL_PLATFORM_NUMERIC_VERSION = 0x0906 # macro
CL_PLATFORM_EXTENSIONS_WITH_VERSION = 0x0907 # macro
CL_DEVICE_TYPE_DEFAULT = (1<<0) # macro
CL_DEVICE_TYPE_CPU = (1<<1) # macro
CL_DEVICE_TYPE_GPU = (1<<2) # macro
CL_DEVICE_TYPE_ACCELERATOR = (1<<3) # macro
CL_DEVICE_TYPE_CUSTOM = (1<<4) # macro
CL_DEVICE_TYPE_ALL = 0xFFFFFFFF # macro
CL_DEVICE_TYPE = 0x1000 # macro
CL_DEVICE_VENDOR_ID = 0x1001 # macro
CL_DEVICE_MAX_COMPUTE_UNITS = 0x1002 # macro
CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS = 0x1003 # macro
CL_DEVICE_MAX_WORK_GROUP_SIZE = 0x1004 # macro
CL_DEVICE_MAX_WORK_ITEM_SIZES = 0x1005 # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR = 0x1006 # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT = 0x1007 # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT = 0x1008 # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG = 0x1009 # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT = 0x100A # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE = 0x100B # macro
CL_DEVICE_MAX_CLOCK_FREQUENCY = 0x100C # macro
CL_DEVICE_ADDRESS_BITS = 0x100D # macro
CL_DEVICE_MAX_READ_IMAGE_ARGS = 0x100E # macro
CL_DEVICE_MAX_WRITE_IMAGE_ARGS = 0x100F # macro
CL_DEVICE_MAX_MEM_ALLOC_SIZE = 0x1010 # macro
CL_DEVICE_IMAGE2D_MAX_WIDTH = 0x1011 # macro
CL_DEVICE_IMAGE2D_MAX_HEIGHT = 0x1012 # macro
CL_DEVICE_IMAGE3D_MAX_WIDTH = 0x1013 # macro
CL_DEVICE_IMAGE3D_MAX_HEIGHT = 0x1014 # macro
CL_DEVICE_IMAGE3D_MAX_DEPTH = 0x1015 # macro
CL_DEVICE_IMAGE_SUPPORT = 0x1016 # macro
CL_DEVICE_MAX_PARAMETER_SIZE = 0x1017 # macro
CL_DEVICE_MAX_SAMPLERS = 0x1018 # macro
CL_DEVICE_MEM_BASE_ADDR_ALIGN = 0x1019 # macro
CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE = 0x101A # macro
CL_DEVICE_SINGLE_FP_CONFIG = 0x101B # macro
CL_DEVICE_GLOBAL_MEM_CACHE_TYPE = 0x101C # macro
CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE = 0x101D # macro
CL_DEVICE_GLOBAL_MEM_CACHE_SIZE = 0x101E # macro
CL_DEVICE_GLOBAL_MEM_SIZE = 0x101F # macro
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE = 0x1020 # macro
CL_DEVICE_MAX_CONSTANT_ARGS = 0x1021 # macro
CL_DEVICE_LOCAL_MEM_TYPE = 0x1022 # macro
CL_DEVICE_LOCAL_MEM_SIZE = 0x1023 # macro
CL_DEVICE_ERROR_CORRECTION_SUPPORT = 0x1024 # macro
CL_DEVICE_PROFILING_TIMER_RESOLUTION = 0x1025 # macro
CL_DEVICE_ENDIAN_LITTLE = 0x1026 # macro
CL_DEVICE_AVAILABLE = 0x1027 # macro
CL_DEVICE_COMPILER_AVAILABLE = 0x1028 # macro
CL_DEVICE_EXECUTION_CAPABILITIES = 0x1029 # macro
CL_DEVICE_QUEUE_PROPERTIES = 0x102A # macro
CL_DEVICE_QUEUE_ON_HOST_PROPERTIES = 0x102A # macro
CL_DEVICE_NAME = 0x102B # macro
CL_DEVICE_VENDOR = 0x102C # macro
CL_DRIVER_VERSION = 0x102D # macro
CL_DEVICE_PROFILE = 0x102E # macro
CL_DEVICE_VERSION = 0x102F # macro
CL_DEVICE_EXTENSIONS = 0x1030 # macro
CL_DEVICE_PLATFORM = 0x1031 # macro
CL_DEVICE_DOUBLE_FP_CONFIG = 0x1032 # macro
CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF = 0x1034 # macro
CL_DEVICE_HOST_UNIFIED_MEMORY = 0x1035 # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR = 0x1036 # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT = 0x1037 # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_INT = 0x1038 # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG = 0x1039 # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT = 0x103A # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE = 0x103B # macro
CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF = 0x103C # macro
CL_DEVICE_OPENCL_C_VERSION = 0x103D # macro
CL_DEVICE_LINKER_AVAILABLE = 0x103E # macro
CL_DEVICE_BUILT_IN_KERNELS = 0x103F # macro
CL_DEVICE_IMAGE_MAX_BUFFER_SIZE = 0x1040 # macro
CL_DEVICE_IMAGE_MAX_ARRAY_SIZE = 0x1041 # macro
CL_DEVICE_PARENT_DEVICE = 0x1042 # macro
CL_DEVICE_PARTITION_MAX_SUB_DEVICES = 0x1043 # macro
CL_DEVICE_PARTITION_PROPERTIES = 0x1044 # macro
CL_DEVICE_PARTITION_AFFINITY_DOMAIN = 0x1045 # macro
CL_DEVICE_PARTITION_TYPE = 0x1046 # macro
CL_DEVICE_REFERENCE_COUNT = 0x1047 # macro
CL_DEVICE_PREFERRED_INTEROP_USER_SYNC = 0x1048 # macro
CL_DEVICE_PRINTF_BUFFER_SIZE = 0x1049 # macro
CL_DEVICE_IMAGE_PITCH_ALIGNMENT = 0x104A # macro
CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT = 0x104B # macro
CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS = 0x104C # macro
CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE = 0x104D # macro
CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES = 0x104E # macro
CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE = 0x104F # macro
CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE = 0x1050 # macro
CL_DEVICE_MAX_ON_DEVICE_QUEUES = 0x1051 # macro
CL_DEVICE_MAX_ON_DEVICE_EVENTS = 0x1052 # macro
CL_DEVICE_SVM_CAPABILITIES = 0x1053 # macro
CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE = 0x1054 # macro
CL_DEVICE_MAX_PIPE_ARGS = 0x1055 # macro
CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS = 0x1056 # macro
CL_DEVICE_PIPE_MAX_PACKET_SIZE = 0x1057 # macro
CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT = 0x1058 # macro
CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT = 0x1059 # macro
CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT = 0x105A # macro
CL_DEVICE_IL_VERSION = 0x105B # macro
CL_DEVICE_MAX_NUM_SUB_GROUPS = 0x105C # macro
CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS = 0x105D # macro
CL_DEVICE_NUMERIC_VERSION = 0x105E # macro
CL_DEVICE_EXTENSIONS_WITH_VERSION = 0x1060 # macro
CL_DEVICE_ILS_WITH_VERSION = 0x1061 # macro
CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION = 0x1062 # macro
CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES = 0x1063 # macro
CL_DEVICE_ATOMIC_FENCE_CAPABILITIES = 0x1064 # macro
CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT = 0x1065 # macro
CL_DEVICE_OPENCL_C_ALL_VERSIONS = 0x1066 # macro
CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x1067 # macro
CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT = 0x1068 # macro
CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT = 0x1069 # macro
CL_DEVICE_OPENCL_C_FEATURES = 0x106F # macro
CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES = 0x1070 # macro
CL_DEVICE_PIPE_SUPPORT = 0x1071 # macro
CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED = 0x1072 # macro
CL_FP_DENORM = (1<<0) # macro
CL_FP_INF_NAN = (1<<1) # macro
CL_FP_ROUND_TO_NEAREST = (1<<2) # macro
CL_FP_ROUND_TO_ZERO = (1<<3) # macro
CL_FP_ROUND_TO_INF = (1<<4) # macro
CL_FP_FMA = (1<<5) # macro
CL_FP_SOFT_FLOAT = (1<<6) # macro
CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT = (1<<7) # macro
CL_NONE = 0x0 # macro
CL_READ_ONLY_CACHE = 0x1 # macro
CL_READ_WRITE_CACHE = 0x2 # macro
CL_LOCAL = 0x1 # macro
CL_GLOBAL = 0x2 # macro
CL_EXEC_KERNEL = (1<<0) # macro
CL_EXEC_NATIVE_KERNEL = (1<<1) # macro
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE = (1<<0) # macro
CL_QUEUE_PROFILING_ENABLE = (1<<1) # macro
CL_QUEUE_ON_DEVICE = (1<<2) # macro
CL_QUEUE_ON_DEVICE_DEFAULT = (1<<3) # macro
CL_CONTEXT_REFERENCE_COUNT = 0x1080 # macro
CL_CONTEXT_DEVICES = 0x1081 # macro
CL_CONTEXT_PROPERTIES = 0x1082 # macro
CL_CONTEXT_NUM_DEVICES = 0x1083 # macro
CL_CONTEXT_PLATFORM = 0x1084 # macro
CL_CONTEXT_INTEROP_USER_SYNC = 0x1085 # macro
CL_DEVICE_PARTITION_EQUALLY = 0x1086 # macro
CL_DEVICE_PARTITION_BY_COUNTS = 0x1087 # macro
CL_DEVICE_PARTITION_BY_COUNTS_LIST_END = 0x0 # macro
CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN = 0x1088 # macro
CL_DEVICE_AFFINITY_DOMAIN_NUMA = (1<<0) # macro
CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE = (1<<1) # macro
CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE = (1<<2) # macro
CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE = (1<<3) # macro
CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE = (1<<4) # macro
CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE = (1<<5) # macro
CL_DEVICE_SVM_COARSE_GRAIN_BUFFER = (1<<0) # macro
CL_DEVICE_SVM_FINE_GRAIN_BUFFER = (1<<1) # macro
CL_DEVICE_SVM_FINE_GRAIN_SYSTEM = (1<<2) # macro
CL_DEVICE_SVM_ATOMICS = (1<<3) # macro
CL_QUEUE_CONTEXT = 0x1090 # macro
CL_QUEUE_DEVICE = 0x1091 # macro
CL_QUEUE_REFERENCE_COUNT = 0x1092 # macro
CL_QUEUE_PROPERTIES = 0x1093 # macro
CL_QUEUE_SIZE = 0x1094 # macro
CL_QUEUE_DEVICE_DEFAULT = 0x1095 # macro
CL_QUEUE_PROPERTIES_ARRAY = 0x1098 # macro
CL_MEM_READ_WRITE = (1<<0) # macro
CL_MEM_WRITE_ONLY = (1<<1) # macro
CL_MEM_READ_ONLY = (1<<2) # macro
CL_MEM_USE_HOST_PTR = (1<<3) # macro
CL_MEM_ALLOC_HOST_PTR = (1<<4) # macro
CL_MEM_COPY_HOST_PTR = (1<<5) # macro
CL_MEM_HOST_WRITE_ONLY = (1<<7) # macro
CL_MEM_HOST_READ_ONLY = (1<<8) # macro
CL_MEM_HOST_NO_ACCESS = (1<<9) # macro
CL_MEM_SVM_FINE_GRAIN_BUFFER = (1<<10) # macro
CL_MEM_SVM_ATOMICS = (1<<11) # macro
CL_MEM_KERNEL_READ_AND_WRITE = (1<<12) # macro
CL_MIGRATE_MEM_OBJECT_HOST = (1<<0) # macro
CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED = (1<<1) # macro
CL_R = 0x10B0 # macro
CL_A = 0x10B1 # macro
CL_RG = 0x10B2 # macro
CL_RA = 0x10B3 # macro
CL_RGB = 0x10B4 # macro
CL_RGBA = 0x10B5 # macro
CL_BGRA = 0x10B6 # macro
CL_ARGB = 0x10B7 # macro
CL_INTENSITY = 0x10B8 # macro
CL_LUMINANCE = 0x10B9 # macro
CL_Rx = 0x10BA # macro
CL_RGx = 0x10BB # macro
CL_RGBx = 0x10BC # macro
CL_DEPTH = 0x10BD # macro
CL_DEPTH_STENCIL = 0x10BE # macro
CL_sRGB = 0x10BF # macro
CL_sRGBx = 0x10C0 # macro
CL_sRGBA = 0x10C1 # macro
CL_sBGRA = 0x10C2 # macro
CL_ABGR = 0x10C3 # macro
CL_SNORM_INT8 = 0x10D0 # macro
CL_SNORM_INT16 = 0x10D1 # macro
CL_UNORM_INT8 = 0x10D2 # macro
CL_UNORM_INT16 = 0x10D3 # macro
CL_UNORM_SHORT_565 = 0x10D4 # macro
CL_UNORM_SHORT_555 = 0x10D5 # macro
CL_UNORM_INT_101010 = 0x10D6 # macro
CL_SIGNED_INT8 = 0x10D7 # macro
CL_SIGNED_INT16 = 0x10D8 # macro
CL_SIGNED_INT32 = 0x10D9 # macro
CL_UNSIGNED_INT8 = 0x10DA # macro
CL_UNSIGNED_INT16 = 0x10DB # macro
CL_UNSIGNED_INT32 = 0x10DC # macro
CL_HALF_FLOAT = 0x10DD # macro
CL_FLOAT = 0x10DE # macro
CL_UNORM_INT24 = 0x10DF # macro
CL_UNORM_INT_101010_2 = 0x10E0 # macro
CL_MEM_OBJECT_BUFFER = 0x10F0 # macro
CL_MEM_OBJECT_IMAGE2D = 0x10F1 # macro
CL_MEM_OBJECT_IMAGE3D = 0x10F2 # macro
CL_MEM_OBJECT_IMAGE2D_ARRAY = 0x10F3 # macro
CL_MEM_OBJECT_IMAGE1D = 0x10F4 # macro
CL_MEM_OBJECT_IMAGE1D_ARRAY = 0x10F5 # macro
CL_MEM_OBJECT_IMAGE1D_BUFFER = 0x10F6 # macro
CL_MEM_OBJECT_PIPE = 0x10F7 # macro
CL_MEM_TYPE = 0x1100 # macro
CL_MEM_FLAGS = 0x1101 # macro
CL_MEM_SIZE = 0x1102 # macro
CL_MEM_HOST_PTR = 0x1103 # macro
CL_MEM_MAP_COUNT = 0x1104 # macro
CL_MEM_REFERENCE_COUNT = 0x1105 # macro
CL_MEM_CONTEXT = 0x1106 # macro
CL_MEM_ASSOCIATED_MEMOBJECT = 0x1107 # macro
CL_MEM_OFFSET = 0x1108 # macro
CL_MEM_USES_SVM_POINTER = 0x1109 # macro
CL_MEM_PROPERTIES = 0x110A # macro
CL_IMAGE_FORMAT = 0x1110 # macro
CL_IMAGE_ELEMENT_SIZE = 0x1111 # macro
CL_IMAGE_ROW_PITCH = 0x1112 # macro
CL_IMAGE_SLICE_PITCH = 0x1113 # macro
CL_IMAGE_WIDTH = 0x1114 # macro
CL_IMAGE_HEIGHT = 0x1115 # macro
CL_IMAGE_DEPTH = 0x1116 # macro
CL_IMAGE_ARRAY_SIZE = 0x1117 # macro
CL_IMAGE_BUFFER = 0x1118 # macro
CL_IMAGE_NUM_MIP_LEVELS = 0x1119 # macro
CL_IMAGE_NUM_SAMPLES = 0x111A # macro
CL_PIPE_PACKET_SIZE = 0x1120 # macro
CL_PIPE_MAX_PACKETS = 0x1121 # macro
CL_PIPE_PROPERTIES = 0x1122 # macro
CL_ADDRESS_NONE = 0x1130 # macro
CL_ADDRESS_CLAMP_TO_EDGE = 0x1131 # macro
CL_ADDRESS_CLAMP = 0x1132 # macro
CL_ADDRESS_REPEAT = 0x1133 # macro
CL_ADDRESS_MIRRORED_REPEAT = 0x1134 # macro
CL_FILTER_NEAREST = 0x1140 # macro
CL_FILTER_LINEAR = 0x1141 # macro
CL_SAMPLER_REFERENCE_COUNT = 0x1150 # macro
CL_SAMPLER_CONTEXT = 0x1151 # macro
CL_SAMPLER_NORMALIZED_COORDS = 0x1152 # macro
CL_SAMPLER_ADDRESSING_MODE = 0x1153 # macro
CL_SAMPLER_FILTER_MODE = 0x1154 # macro
CL_SAMPLER_MIP_FILTER_MODE = 0x1155 # macro
CL_SAMPLER_LOD_MIN = 0x1156 # macro
CL_SAMPLER_LOD_MAX = 0x1157 # macro
CL_SAMPLER_PROPERTIES = 0x1158 # macro
CL_MAP_READ = (1<<0) # macro
CL_MAP_WRITE = (1<<1) # macro
CL_MAP_WRITE_INVALIDATE_REGION = (1<<2) # macro
CL_PROGRAM_REFERENCE_COUNT = 0x1160 # macro
CL_PROGRAM_CONTEXT = 0x1161 # macro
CL_PROGRAM_NUM_DEVICES = 0x1162 # macro
CL_PROGRAM_DEVICES = 0x1163 # macro
CL_PROGRAM_SOURCE = 0x1164 # macro
CL_PROGRAM_BINARY_SIZES = 0x1165 # macro
CL_PROGRAM_BINARIES = 0x1166 # macro
CL_PROGRAM_NUM_KERNELS = 0x1167 # macro
CL_PROGRAM_KERNEL_NAMES = 0x1168 # macro
CL_PROGRAM_IL = 0x1169 # macro
CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT = 0x116A # macro
CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT = 0x116B # macro
CL_PROGRAM_BUILD_STATUS = 0x1181 # macro
CL_PROGRAM_BUILD_OPTIONS = 0x1182 # macro
CL_PROGRAM_BUILD_LOG = 0x1183 # macro
CL_PROGRAM_BINARY_TYPE = 0x1184 # macro
CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE = 0x1185 # macro
CL_PROGRAM_BINARY_TYPE_NONE = 0x0 # macro
CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT = 0x1 # macro
CL_PROGRAM_BINARY_TYPE_LIBRARY = 0x2 # macro
CL_PROGRAM_BINARY_TYPE_EXECUTABLE = 0x4 # macro
CL_BUILD_SUCCESS = 0 # macro
CL_BUILD_NONE = -1 # macro
CL_BUILD_ERROR = -2 # macro
CL_BUILD_IN_PROGRESS = -3 # macro
CL_KERNEL_FUNCTION_NAME = 0x1190 # macro
CL_KERNEL_NUM_ARGS = 0x1191 # macro
CL_KERNEL_REFERENCE_COUNT = 0x1192 # macro
CL_KERNEL_CONTEXT = 0x1193 # macro
CL_KERNEL_PROGRAM = 0x1194 # macro
CL_KERNEL_ATTRIBUTES = 0x1195 # macro
CL_KERNEL_ARG_ADDRESS_QUALIFIER = 0x1196 # macro
CL_KERNEL_ARG_ACCESS_QUALIFIER = 0x1197 # macro
CL_KERNEL_ARG_TYPE_NAME = 0x1198 # macro
CL_KERNEL_ARG_TYPE_QUALIFIER = 0x1199 # macro
CL_KERNEL_ARG_NAME = 0x119A # macro
CL_KERNEL_ARG_ADDRESS_GLOBAL = 0x119B # macro
CL_KERNEL_ARG_ADDRESS_LOCAL = 0x119C # macro
CL_KERNEL_ARG_ADDRESS_CONSTANT = 0x119D # macro
CL_KERNEL_ARG_ADDRESS_PRIVATE = 0x119E # macro
CL_KERNEL_ARG_ACCESS_READ_ONLY = 0x11A0 # macro
CL_KERNEL_ARG_ACCESS_WRITE_ONLY = 0x11A1 # macro
CL_KERNEL_ARG_ACCESS_READ_WRITE = 0x11A2 # macro
CL_KERNEL_ARG_ACCESS_NONE = 0x11A3 # macro
CL_KERNEL_ARG_TYPE_NONE = 0 # macro
CL_KERNEL_ARG_TYPE_CONST = (1<<0) # macro
CL_KERNEL_ARG_TYPE_RESTRICT = (1<<1) # macro
CL_KERNEL_ARG_TYPE_VOLATILE = (1<<2) # macro
CL_KERNEL_ARG_TYPE_PIPE = (1<<3) # macro
CL_KERNEL_WORK_GROUP_SIZE = 0x11B0 # macro
CL_KERNEL_COMPILE_WORK_GROUP_SIZE = 0x11B1 # macro
CL_KERNEL_LOCAL_MEM_SIZE = 0x11B2 # macro
CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x11B3 # macro
CL_KERNEL_PRIVATE_MEM_SIZE = 0x11B4 # macro
CL_KERNEL_GLOBAL_WORK_SIZE = 0x11B5 # macro
CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE = 0x2033 # macro
CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE = 0x2034 # macro
CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT = 0x11B8 # macro
CL_KERNEL_MAX_NUM_SUB_GROUPS = 0x11B9 # macro
CL_KERNEL_COMPILE_NUM_SUB_GROUPS = 0x11BA # macro
CL_KERNEL_EXEC_INFO_SVM_PTRS = 0x11B6 # macro
CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM = 0x11B7 # macro
CL_EVENT_COMMAND_QUEUE = 0x11D0 # macro
CL_EVENT_COMMAND_TYPE = 0x11D1 # macro
CL_EVENT_REFERENCE_COUNT = 0x11D2 # macro
CL_EVENT_COMMAND_EXECUTION_STATUS = 0x11D3 # macro
CL_EVENT_CONTEXT = 0x11D4 # macro
CL_COMMAND_NDRANGE_KERNEL = 0x11F0 # macro
CL_COMMAND_TASK = 0x11F1 # macro
CL_COMMAND_NATIVE_KERNEL = 0x11F2 # macro
CL_COMMAND_READ_BUFFER = 0x11F3 # macro
CL_COMMAND_WRITE_BUFFER = 0x11F4 # macro
CL_COMMAND_COPY_BUFFER = 0x11F5 # macro
CL_COMMAND_READ_IMAGE = 0x11F6 # macro
CL_COMMAND_WRITE_IMAGE = 0x11F7 # macro
CL_COMMAND_COPY_IMAGE = 0x11F8 # macro
CL_COMMAND_COPY_IMAGE_TO_BUFFER = 0x11F9 # macro
CL_COMMAND_COPY_BUFFER_TO_IMAGE = 0x11FA # macro
CL_COMMAND_MAP_BUFFER = 0x11FB # macro
CL_COMMAND_MAP_IMAGE = 0x11FC # macro
CL_COMMAND_UNMAP_MEM_OBJECT = 0x11FD # macro
CL_COMMAND_MARKER = 0x11FE # macro
CL_COMMAND_ACQUIRE_GL_OBJECTS = 0x11FF # macro
CL_COMMAND_RELEASE_GL_OBJECTS = 0x1200 # macro
CL_COMMAND_READ_BUFFER_RECT = 0x1201 # macro
CL_COMMAND_WRITE_BUFFER_RECT = 0x1202 # macro
CL_COMMAND_COPY_BUFFER_RECT = 0x1203 # macro
CL_COMMAND_USER = 0x1204 # macro
CL_COMMAND_BARRIER = 0x1205 # macro
CL_COMMAND_MIGRATE_MEM_OBJECTS = 0x1206 # macro
CL_COMMAND_FILL_BUFFER = 0x1207 # macro
CL_COMMAND_FILL_IMAGE = 0x1208 # macro
CL_COMMAND_SVM_FREE = 0x1209 # macro
CL_COMMAND_SVM_MEMCPY = 0x120A # macro
CL_COMMAND_SVM_MEMFILL = 0x120B # macro
CL_COMMAND_SVM_MAP = 0x120C # macro
CL_COMMAND_SVM_UNMAP = 0x120D # macro
CL_COMMAND_SVM_MIGRATE_MEM = 0x120E # macro
CL_COMPLETE = 0x0 # macro
CL_RUNNING = 0x1 # macro
CL_SUBMITTED = 0x2 # macro
CL_QUEUED = 0x3 # macro
CL_BUFFER_CREATE_TYPE_REGION = 0x1220 # macro
CL_PROFILING_COMMAND_QUEUED = 0x1280 # macro
CL_PROFILING_COMMAND_SUBMIT = 0x1281 # macro
CL_PROFILING_COMMAND_START = 0x1282 # macro
CL_PROFILING_COMMAND_END = 0x1283 # macro
CL_PROFILING_COMMAND_COMPLETE = 0x1284 # macro
CL_DEVICE_ATOMIC_ORDER_RELAXED = (1<<0) # macro
CL_DEVICE_ATOMIC_ORDER_ACQ_REL = (1<<1) # macro
CL_DEVICE_ATOMIC_ORDER_SEQ_CST = (1<<2) # macro
CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM = (1<<3) # macro
CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP = (1<<4) # macro
CL_DEVICE_ATOMIC_SCOPE_DEVICE = (1<<5) # macro
CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES = (1<<6) # macro
CL_DEVICE_QUEUE_SUPPORTED = (1<<0) # macro
CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT = (1<<1) # macro
CL_KHRONOS_VENDOR_ID_CODEPLAY = 0x10004 # macro
CL_VERSION_MAJOR_BITS = (10) # macro
CL_VERSION_MINOR_BITS = (10) # macro
CL_VERSION_PATCH_BITS = (12) # macro
# CL_VERSION_MAJOR_MASK = ((1<<(10)) # macro
# CL_VERSION_MINOR_MASK = ((1<<(10)) # macro
# CL_VERSION_PATCH_MASK = ((1<<(12)) # macro
# def CL_VERSION_MAJOR(version):  # macro
#    return ((version)>>((10)+(12)))
# def CL_VERSION_MINOR(version):  # macro
#    return (((version)>>(12))&((1<<(10)))
# def CL_VERSION_PATCH(version):  # macro
#    return ((version)&((1<<(12)))
# def CL_MAKE_VERSION(major, minor, patch):  # macro
#    return ((((major)&((1<<(10)))<<((10)+(12)))|(((minor)&((1<<(10)))<<(12))|((patch)&((1<<(12))))
class struct__cl_platform_id(Structure):
    pass

cl_platform_id = ctypes.POINTER(struct__cl_platform_id)
class struct__cl_device_id(Structure):
    pass

cl_device_id = ctypes.POINTER(struct__cl_device_id)
class struct__cl_context(Structure):
    pass

cl_context = ctypes.POINTER(struct__cl_context)
class struct__cl_command_queue(Structure):
    pass

cl_command_queue = ctypes.POINTER(struct__cl_command_queue)
class struct__cl_mem(Structure):
    pass

cl_mem = ctypes.POINTER(struct__cl_mem)
class struct__cl_program(Structure):
    pass

cl_program = ctypes.POINTER(struct__cl_program)
class struct__cl_kernel(Structure):
    pass

cl_kernel = ctypes.POINTER(struct__cl_kernel)
class struct__cl_event(Structure):
    pass

cl_event = ctypes.POINTER(struct__cl_event)
class struct__cl_sampler(Structure):
    pass

cl_sampler = ctypes.POINTER(struct__cl_sampler)
cl_bool = ctypes.c_uint32
cl_bitfield = ctypes.c_uint64
cl_properties = ctypes.c_uint64
cl_device_type = ctypes.c_uint64
cl_platform_info = ctypes.c_uint32
cl_device_info = ctypes.c_uint32
cl_device_fp_config = ctypes.c_uint64
cl_device_mem_cache_type = ctypes.c_uint32
cl_device_local_mem_type = ctypes.c_uint32
cl_device_exec_capabilities = ctypes.c_uint64
cl_device_svm_capabilities = ctypes.c_uint64
cl_command_queue_properties = ctypes.c_uint64
cl_device_partition_property = ctypes.c_int64
cl_device_affinity_domain = ctypes.c_uint64
cl_context_properties = ctypes.c_int64
cl_context_info = ctypes.c_uint32
cl_queue_properties = ctypes.c_uint64
cl_command_queue_info = ctypes.c_uint32
cl_channel_order = ctypes.c_uint32
cl_channel_type = ctypes.c_uint32
cl_mem_flags = ctypes.c_uint64
cl_svm_mem_flags = ctypes.c_uint64
cl_mem_object_type = ctypes.c_uint32
cl_mem_info = ctypes.c_uint32
cl_mem_migration_flags = ctypes.c_uint64
cl_image_info = ctypes.c_uint32
cl_buffer_create_type = ctypes.c_uint32
cl_addressing_mode = ctypes.c_uint32
cl_filter_mode = ctypes.c_uint32
cl_sampler_info = ctypes.c_uint32
cl_map_flags = ctypes.c_uint64
cl_pipe_properties = ctypes.c_int64
cl_pipe_info = ctypes.c_uint32
cl_program_info = ctypes.c_uint32
cl_program_build_info = ctypes.c_uint32
cl_program_binary_type = ctypes.c_uint32
cl_build_status = ctypes.c_int32
cl_kernel_info = ctypes.c_uint32
cl_kernel_arg_info = ctypes.c_uint32
cl_kernel_arg_address_qualifier = ctypes.c_uint32
cl_kernel_arg_access_qualifier = ctypes.c_uint32
cl_kernel_arg_type_qualifier = ctypes.c_uint64
cl_kernel_work_group_info = ctypes.c_uint32
cl_kernel_sub_group_info = ctypes.c_uint32
cl_event_info = ctypes.c_uint32
cl_command_type = ctypes.c_uint32
cl_profiling_info = ctypes.c_uint32
cl_sampler_properties = ctypes.c_uint64
cl_kernel_exec_info = ctypes.c_uint32
cl_device_atomic_capabilities = ctypes.c_uint64
cl_device_device_enqueue_capabilities = ctypes.c_uint64
cl_khronos_vendor_id = ctypes.c_uint32
cl_mem_properties = ctypes.c_uint64
cl_version = ctypes.c_uint32
class struct__cl_image_format(Structure):
    pass

struct__cl_image_format._pack_ = 1 # source:False
struct__cl_image_format._fields_ = [
    ('image_channel_order', ctypes.c_uint32),
    ('image_channel_data_type', ctypes.c_uint32),
]

cl_image_format = struct__cl_image_format
class struct__cl_image_desc(Structure):
    pass

class union__cl_image_desc_0(Union):
    pass

union__cl_image_desc_0._pack_ = 1 # source:False
union__cl_image_desc_0._fields_ = [
    ('buffer', ctypes.POINTER(struct__cl_mem)),
    ('mem_object', ctypes.POINTER(struct__cl_mem)),
]

struct__cl_image_desc._pack_ = 1 # source:False
struct__cl_image_desc._anonymous_ = ('_0',)
struct__cl_image_desc._fields_ = [
    ('image_type', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('image_width', ctypes.c_uint64),
    ('image_height', ctypes.c_uint64),
    ('image_depth', ctypes.c_uint64),
    ('image_array_size', ctypes.c_uint64),
    ('image_row_pitch', ctypes.c_uint64),
    ('image_slice_pitch', ctypes.c_uint64),
    ('num_mip_levels', ctypes.c_uint32),
    ('num_samples', ctypes.c_uint32),
    ('_0', union__cl_image_desc_0),
]

cl_image_desc = struct__cl_image_desc
class struct__cl_buffer_region(Structure):
    pass

struct__cl_buffer_region._pack_ = 1 # source:False
struct__cl_buffer_region._fields_ = [
    ('origin', ctypes.c_uint64),
    ('size', ctypes.c_uint64),
]

cl_buffer_region = struct__cl_buffer_region
class struct__cl_name_version(Structure):
    pass

struct__cl_name_version._pack_ = 1 # source:False
struct__cl_name_version._fields_ = [
    ('version', ctypes.c_uint32),
    ('name', ctypes.c_char * 64),
]

cl_name_version = struct__cl_name_version
cl_int = ctypes.c_int32
cl_uint = ctypes.c_uint32
try:
    clGetPlatformIDs = _libraries['libOpenCL.so.1'].clGetPlatformIDs
    clGetPlatformIDs.restype = cl_int
    clGetPlatformIDs.argtypes = [cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_platform_id)), ctypes.POINTER(ctypes.c_uint32)]
except AttributeError:
    pass
size_t = ctypes.c_uint64
try:
    clGetPlatformInfo = _libraries['libOpenCL.so.1'].clGetPlatformInfo
    clGetPlatformInfo.restype = cl_int
    clGetPlatformInfo.argtypes = [cl_platform_id, cl_platform_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetDeviceIDs = _libraries['libOpenCL.so.1'].clGetDeviceIDs
    clGetDeviceIDs.restype = cl_int
    clGetDeviceIDs.argtypes = [cl_platform_id, cl_device_type, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_uint32)]
except AttributeError:
    pass
try:
    clGetDeviceInfo = _libraries['libOpenCL.so.1'].clGetDeviceInfo
    clGetDeviceInfo.restype = cl_int
    clGetDeviceInfo.argtypes = [cl_device_id, cl_device_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clCreateSubDevices = _libraries['libOpenCL.so.1'].clCreateSubDevices
    clCreateSubDevices.restype = cl_int
    clCreateSubDevices.argtypes = [cl_device_id, ctypes.POINTER(ctypes.c_int64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_uint32)]
except AttributeError:
    pass
try:
    clRetainDevice = _libraries['libOpenCL.so.1'].clRetainDevice
    clRetainDevice.restype = cl_int
    clRetainDevice.argtypes = [cl_device_id]
except AttributeError:
    pass
try:
    clReleaseDevice = _libraries['libOpenCL.so.1'].clReleaseDevice
    clReleaseDevice.restype = cl_int
    clReleaseDevice.argtypes = [cl_device_id]
except AttributeError:
    pass
try:
    clSetDefaultDeviceCommandQueue = _libraries['libOpenCL.so.1'].clSetDefaultDeviceCommandQueue
    clSetDefaultDeviceCommandQueue.restype = cl_int
    clSetDefaultDeviceCommandQueue.argtypes = [cl_context, cl_device_id, cl_command_queue]
except AttributeError:
    pass
try:
    clGetDeviceAndHostTimer = _libraries['libOpenCL.so.1'].clGetDeviceAndHostTimer
    clGetDeviceAndHostTimer.restype = cl_int
    clGetDeviceAndHostTimer.argtypes = [cl_device_id, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetHostTimer = _libraries['libOpenCL.so.1'].clGetHostTimer
    clGetHostTimer.restype = cl_int
    clGetHostTimer.argtypes = [cl_device_id, ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clCreateContext = _libraries['libOpenCL.so.1'].clCreateContext
    clCreateContext.restype = cl_context
    clCreateContext.argtypes = [ctypes.POINTER(ctypes.c_int64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.CFUNCTYPE(None, ctypes.POINTER(ctypes.c_char), ctypes.POINTER(None), ctypes.c_uint64, ctypes.POINTER(None)), ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateContextFromType = _libraries['libOpenCL.so.1'].clCreateContextFromType
    clCreateContextFromType.restype = cl_context
    clCreateContextFromType.argtypes = [ctypes.POINTER(ctypes.c_int64), cl_device_type, ctypes.CFUNCTYPE(None, ctypes.POINTER(ctypes.c_char), ctypes.POINTER(None), ctypes.c_uint64, ctypes.POINTER(None)), ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainContext = _libraries['libOpenCL.so.1'].clRetainContext
    clRetainContext.restype = cl_int
    clRetainContext.argtypes = [cl_context]
except AttributeError:
    pass
try:
    clReleaseContext = _libraries['libOpenCL.so.1'].clReleaseContext
    clReleaseContext.restype = cl_int
    clReleaseContext.argtypes = [cl_context]
except AttributeError:
    pass
try:
    clGetContextInfo = _libraries['libOpenCL.so.1'].clGetContextInfo
    clGetContextInfo.restype = cl_int
    clGetContextInfo.argtypes = [cl_context, cl_context_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clSetContextDestructorCallback = _libraries['libOpenCL.so.1'].clSetContextDestructorCallback
    clSetContextDestructorCallback.restype = cl_int
    clSetContextDestructorCallback.argtypes = [cl_context, ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_context), ctypes.POINTER(None)), ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clCreateCommandQueueWithProperties = _libraries['libOpenCL.so.1'].clCreateCommandQueueWithProperties
    clCreateCommandQueueWithProperties.restype = cl_command_queue
    clCreateCommandQueueWithProperties.argtypes = [cl_context, cl_device_id, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainCommandQueue = _libraries['libOpenCL.so.1'].clRetainCommandQueue
    clRetainCommandQueue.restype = cl_int
    clRetainCommandQueue.argtypes = [cl_command_queue]
except AttributeError:
    pass
try:
    clReleaseCommandQueue = _libraries['libOpenCL.so.1'].clReleaseCommandQueue
    clReleaseCommandQueue.restype = cl_int
    clReleaseCommandQueue.argtypes = [cl_command_queue]
except AttributeError:
    pass
try:
    clGetCommandQueueInfo = _libraries['libOpenCL.so.1'].clGetCommandQueueInfo
    clGetCommandQueueInfo.restype = cl_int
    clGetCommandQueueInfo.argtypes = [cl_command_queue, cl_command_queue_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clCreateBuffer = _libraries['libOpenCL.so.1'].clCreateBuffer
    clCreateBuffer.restype = cl_mem
    clCreateBuffer.argtypes = [cl_context, cl_mem_flags, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateSubBuffer = _libraries['libOpenCL.so.1'].clCreateSubBuffer
    clCreateSubBuffer.restype = cl_mem
    clCreateSubBuffer.argtypes = [cl_mem, cl_mem_flags, cl_buffer_create_type, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateImage = _libraries['libOpenCL.so.1'].clCreateImage
    clCreateImage.restype = cl_mem
    clCreateImage.argtypes = [cl_context, cl_mem_flags, ctypes.POINTER(struct__cl_image_format), ctypes.POINTER(struct__cl_image_desc), ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreatePipe = _libraries['libOpenCL.so.1'].clCreatePipe
    clCreatePipe.restype = cl_mem
    clCreatePipe.argtypes = [cl_context, cl_mem_flags, cl_uint, cl_uint, ctypes.POINTER(ctypes.c_int64), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateBufferWithProperties = _libraries['libOpenCL.so.1'].clCreateBufferWithProperties
    clCreateBufferWithProperties.restype = cl_mem
    clCreateBufferWithProperties.argtypes = [cl_context, ctypes.POINTER(ctypes.c_uint64), cl_mem_flags, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateImageWithProperties = _libraries['libOpenCL.so.1'].clCreateImageWithProperties
    clCreateImageWithProperties.restype = cl_mem
    clCreateImageWithProperties.argtypes = [cl_context, ctypes.POINTER(ctypes.c_uint64), cl_mem_flags, ctypes.POINTER(struct__cl_image_format), ctypes.POINTER(struct__cl_image_desc), ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainMemObject = _libraries['libOpenCL.so.1'].clRetainMemObject
    clRetainMemObject.restype = cl_int
    clRetainMemObject.argtypes = [cl_mem]
except AttributeError:
    pass
try:
    clReleaseMemObject = _libraries['libOpenCL.so.1'].clReleaseMemObject
    clReleaseMemObject.restype = cl_int
    clReleaseMemObject.argtypes = [cl_mem]
except AttributeError:
    pass
try:
    clGetSupportedImageFormats = _libraries['libOpenCL.so.1'].clGetSupportedImageFormats
    clGetSupportedImageFormats.restype = cl_int
    clGetSupportedImageFormats.argtypes = [cl_context, cl_mem_flags, cl_mem_object_type, cl_uint, ctypes.POINTER(struct__cl_image_format), ctypes.POINTER(ctypes.c_uint32)]
except AttributeError:
    pass
try:
    clGetMemObjectInfo = _libraries['libOpenCL.so.1'].clGetMemObjectInfo
    clGetMemObjectInfo.restype = cl_int
    clGetMemObjectInfo.argtypes = [cl_mem, cl_mem_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetImageInfo = _libraries['libOpenCL.so.1'].clGetImageInfo
    clGetImageInfo.restype = cl_int
    clGetImageInfo.argtypes = [cl_mem, cl_image_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetPipeInfo = _libraries['libOpenCL.so.1'].clGetPipeInfo
    clGetPipeInfo.restype = cl_int
    clGetPipeInfo.argtypes = [cl_mem, cl_pipe_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clSetMemObjectDestructorCallback = _libraries['libOpenCL.so.1'].clSetMemObjectDestructorCallback
    clSetMemObjectDestructorCallback.restype = cl_int
    clSetMemObjectDestructorCallback.argtypes = [cl_mem, ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_mem), ctypes.POINTER(None)), ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clSVMAlloc = _libraries['libOpenCL.so.1'].clSVMAlloc
    clSVMAlloc.restype = ctypes.POINTER(None)
    clSVMAlloc.argtypes = [cl_context, cl_svm_mem_flags, size_t, cl_uint]
except AttributeError:
    pass
try:
    clSVMFree = _libraries['libOpenCL.so.1'].clSVMFree
    clSVMFree.restype = None
    clSVMFree.argtypes = [cl_context, ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clCreateSamplerWithProperties = _libraries['libOpenCL.so.1'].clCreateSamplerWithProperties
    clCreateSamplerWithProperties.restype = cl_sampler
    clCreateSamplerWithProperties.argtypes = [cl_context, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainSampler = _libraries['libOpenCL.so.1'].clRetainSampler
    clRetainSampler.restype = cl_int
    clRetainSampler.argtypes = [cl_sampler]
except AttributeError:
    pass
try:
    clReleaseSampler = _libraries['libOpenCL.so.1'].clReleaseSampler
    clReleaseSampler.restype = cl_int
    clReleaseSampler.argtypes = [cl_sampler]
except AttributeError:
    pass
try:
    clGetSamplerInfo = _libraries['libOpenCL.so.1'].clGetSamplerInfo
    clGetSamplerInfo.restype = cl_int
    clGetSamplerInfo.argtypes = [cl_sampler, cl_sampler_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clCreateProgramWithSource = _libraries['libOpenCL.so.1'].clCreateProgramWithSource
    clCreateProgramWithSource.restype = cl_program
    clCreateProgramWithSource.argtypes = [cl_context, cl_uint, ctypes.POINTER(ctypes.POINTER(ctypes.c_char)), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateProgramWithBinary = _libraries['libOpenCL.so.1'].clCreateProgramWithBinary
    clCreateProgramWithBinary.restype = cl_program
    clCreateProgramWithBinary.argtypes = [cl_context, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.POINTER(ctypes.c_ubyte)), ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateProgramWithBuiltInKernels = _libraries['libOpenCL.so.1'].clCreateProgramWithBuiltInKernels
    clCreateProgramWithBuiltInKernels.restype = cl_program
    clCreateProgramWithBuiltInKernels.argtypes = [cl_context, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_char), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateProgramWithIL = _libraries['libOpenCL.so.1'].clCreateProgramWithIL
    clCreateProgramWithIL.restype = cl_program
    clCreateProgramWithIL.argtypes = [cl_context, ctypes.POINTER(None), size_t, ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainProgram = _libraries['libOpenCL.so.1'].clRetainProgram
    clRetainProgram.restype = cl_int
    clRetainProgram.argtypes = [cl_program]
except AttributeError:
    pass
try:
    clReleaseProgram = _libraries['libOpenCL.so.1'].clReleaseProgram
    clReleaseProgram.restype = cl_int
    clReleaseProgram.argtypes = [cl_program]
except AttributeError:
    pass
try:
    clBuildProgram = _libraries['libOpenCL.so.1'].clBuildProgram
    clBuildProgram.restype = cl_int
    clBuildProgram.argtypes = [cl_program, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_char), ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_program), ctypes.POINTER(None)), ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clCompileProgram = _libraries['libOpenCL.so.1'].clCompileProgram
    clCompileProgram.restype = cl_int
    clCompileProgram.argtypes = [cl_program, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_char), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_program)), ctypes.POINTER(ctypes.POINTER(ctypes.c_char)), ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_program), ctypes.POINTER(None)), ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clLinkProgram = _libraries['libOpenCL.so.1'].clLinkProgram
    clLinkProgram.restype = cl_program
    clLinkProgram.argtypes = [cl_context, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_device_id)), ctypes.POINTER(ctypes.c_char), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_program)), ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_program), ctypes.POINTER(None)), ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clSetProgramReleaseCallback = _libraries['libOpenCL.so.1'].clSetProgramReleaseCallback
    clSetProgramReleaseCallback.restype = cl_int
    clSetProgramReleaseCallback.argtypes = [cl_program, ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_program), ctypes.POINTER(None)), ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clSetProgramSpecializationConstant = _libraries['libOpenCL.so.1'].clSetProgramSpecializationConstant
    clSetProgramSpecializationConstant.restype = cl_int
    clSetProgramSpecializationConstant.argtypes = [cl_program, cl_uint, size_t, ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clUnloadPlatformCompiler = _libraries['libOpenCL.so.1'].clUnloadPlatformCompiler
    clUnloadPlatformCompiler.restype = cl_int
    clUnloadPlatformCompiler.argtypes = [cl_platform_id]
except AttributeError:
    pass
try:
    clGetProgramInfo = _libraries['libOpenCL.so.1'].clGetProgramInfo
    clGetProgramInfo.restype = cl_int
    clGetProgramInfo.argtypes = [cl_program, cl_program_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetProgramBuildInfo = _libraries['libOpenCL.so.1'].clGetProgramBuildInfo
    clGetProgramBuildInfo.restype = cl_int
    clGetProgramBuildInfo.argtypes = [cl_program, cl_device_id, cl_program_build_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clCreateKernel = _libraries['libOpenCL.so.1'].clCreateKernel
    clCreateKernel.restype = cl_kernel
    clCreateKernel.argtypes = [cl_program, ctypes.POINTER(ctypes.c_char), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateKernelsInProgram = _libraries['libOpenCL.so.1'].clCreateKernelsInProgram
    clCreateKernelsInProgram.restype = cl_int
    clCreateKernelsInProgram.argtypes = [cl_program, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_kernel)), ctypes.POINTER(ctypes.c_uint32)]
except AttributeError:
    pass
try:
    clCloneKernel = _libraries['libOpenCL.so.1'].clCloneKernel
    clCloneKernel.restype = cl_kernel
    clCloneKernel.argtypes = [cl_kernel, ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainKernel = _libraries['libOpenCL.so.1'].clRetainKernel
    clRetainKernel.restype = cl_int
    clRetainKernel.argtypes = [cl_kernel]
except AttributeError:
    pass
try:
    clReleaseKernel = _libraries['libOpenCL.so.1'].clReleaseKernel
    clReleaseKernel.restype = cl_int
    clReleaseKernel.argtypes = [cl_kernel]
except AttributeError:
    pass
try:
    clSetKernelArg = _libraries['libOpenCL.so.1'].clSetKernelArg
    clSetKernelArg.restype = cl_int
    clSetKernelArg.argtypes = [cl_kernel, cl_uint, size_t, ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clSetKernelArgSVMPointer = _libraries['libOpenCL.so.1'].clSetKernelArgSVMPointer
    clSetKernelArgSVMPointer.restype = cl_int
    clSetKernelArgSVMPointer.argtypes = [cl_kernel, cl_uint, ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clSetKernelExecInfo = _libraries['libOpenCL.so.1'].clSetKernelExecInfo
    clSetKernelExecInfo.restype = cl_int
    clSetKernelExecInfo.argtypes = [cl_kernel, cl_kernel_exec_info, size_t, ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clGetKernelInfo = _libraries['libOpenCL.so.1'].clGetKernelInfo
    clGetKernelInfo.restype = cl_int
    clGetKernelInfo.argtypes = [cl_kernel, cl_kernel_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetKernelArgInfo = _libraries['libOpenCL.so.1'].clGetKernelArgInfo
    clGetKernelArgInfo.restype = cl_int
    clGetKernelArgInfo.argtypes = [cl_kernel, cl_uint, cl_kernel_arg_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetKernelWorkGroupInfo = _libraries['libOpenCL.so.1'].clGetKernelWorkGroupInfo
    clGetKernelWorkGroupInfo.restype = cl_int
    clGetKernelWorkGroupInfo.argtypes = [cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clGetKernelSubGroupInfo = _libraries['libOpenCL.so.1'].clGetKernelSubGroupInfo
    clGetKernelSubGroupInfo.restype = cl_int
    clGetKernelSubGroupInfo.argtypes = [cl_kernel, cl_device_id, cl_kernel_sub_group_info, size_t, ctypes.POINTER(None), size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clWaitForEvents = _libraries['libOpenCL.so.1'].clWaitForEvents
    clWaitForEvents.restype = cl_int
    clWaitForEvents.argtypes = [cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clGetEventInfo = _libraries['libOpenCL.so.1'].clGetEventInfo
    clGetEventInfo.restype = cl_int
    clGetEventInfo.argtypes = [cl_event, cl_event_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clCreateUserEvent = _libraries['libOpenCL.so.1'].clCreateUserEvent
    clCreateUserEvent.restype = cl_event
    clCreateUserEvent.argtypes = [cl_context, ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clRetainEvent = _libraries['libOpenCL.so.1'].clRetainEvent
    clRetainEvent.restype = cl_int
    clRetainEvent.argtypes = [cl_event]
except AttributeError:
    pass
try:
    clReleaseEvent = _libraries['libOpenCL.so.1'].clReleaseEvent
    clReleaseEvent.restype = cl_int
    clReleaseEvent.argtypes = [cl_event]
except AttributeError:
    pass
try:
    clSetUserEventStatus = _libraries['libOpenCL.so.1'].clSetUserEventStatus
    clSetUserEventStatus.restype = cl_int
    clSetUserEventStatus.argtypes = [cl_event, cl_int]
except AttributeError:
    pass
try:
    clSetEventCallback = _libraries['libOpenCL.so.1'].clSetEventCallback
    clSetEventCallback.restype = cl_int
    clSetEventCallback.argtypes = [cl_event, cl_int, ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_event), ctypes.c_int32, ctypes.POINTER(None)), ctypes.POINTER(None)]
except AttributeError:
    pass
try:
    clGetEventProfilingInfo = _libraries['libOpenCL.so.1'].clGetEventProfilingInfo
    clGetEventProfilingInfo.restype = cl_int
    clGetEventProfilingInfo.argtypes = [cl_event, cl_profiling_info, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
except AttributeError:
    pass
try:
    clFlush = _libraries['libOpenCL.so.1'].clFlush
    clFlush.restype = cl_int
    clFlush.argtypes = [cl_command_queue]
except AttributeError:
    pass
try:
    clFinish = _libraries['libOpenCL.so.1'].clFinish
    clFinish.restype = cl_int
    clFinish.argtypes = [cl_command_queue]
except AttributeError:
    pass
try:
    clEnqueueReadBuffer = _libraries['libOpenCL.so.1'].clEnqueueReadBuffer
    clEnqueueReadBuffer.restype = cl_int
    clEnqueueReadBuffer.argtypes = [cl_command_queue, cl_mem, cl_bool, size_t, size_t, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueReadBufferRect = _libraries['libOpenCL.so.1'].clEnqueueReadBufferRect
    clEnqueueReadBufferRect.restype = cl_int
    clEnqueueReadBufferRect.argtypes = [cl_command_queue, cl_mem, cl_bool, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, size_t, size_t, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueWriteBuffer = _libraries['libOpenCL.so.1'].clEnqueueWriteBuffer
    clEnqueueWriteBuffer.restype = cl_int
    clEnqueueWriteBuffer.argtypes = [cl_command_queue, cl_mem, cl_bool, size_t, size_t, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueWriteBufferRect = _libraries['libOpenCL.so.1'].clEnqueueWriteBufferRect
    clEnqueueWriteBufferRect.restype = cl_int
    clEnqueueWriteBufferRect.argtypes = [cl_command_queue, cl_mem, cl_bool, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, size_t, size_t, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueFillBuffer = _libraries['libOpenCL.so.1'].clEnqueueFillBuffer
    clEnqueueFillBuffer.restype = cl_int
    clEnqueueFillBuffer.argtypes = [cl_command_queue, cl_mem, ctypes.POINTER(None), size_t, size_t, size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueCopyBuffer = _libraries['libOpenCL.so.1'].clEnqueueCopyBuffer
    clEnqueueCopyBuffer.restype = cl_int
    clEnqueueCopyBuffer.argtypes = [cl_command_queue, cl_mem, cl_mem, size_t, size_t, size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueCopyBufferRect = _libraries['libOpenCL.so.1'].clEnqueueCopyBufferRect
    clEnqueueCopyBufferRect.restype = cl_int
    clEnqueueCopyBufferRect.argtypes = [cl_command_queue, cl_mem, cl_mem, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, size_t, size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueReadImage = _libraries['libOpenCL.so.1'].clEnqueueReadImage
    clEnqueueReadImage.restype = cl_int
    clEnqueueReadImage.argtypes = [cl_command_queue, cl_mem, cl_bool, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueWriteImage = _libraries['libOpenCL.so.1'].clEnqueueWriteImage
    clEnqueueWriteImage.restype = cl_int
    clEnqueueWriteImage.argtypes = [cl_command_queue, cl_mem, cl_bool, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueFillImage = _libraries['libOpenCL.so.1'].clEnqueueFillImage
    clEnqueueFillImage.restype = cl_int
    clEnqueueFillImage.argtypes = [cl_command_queue, cl_mem, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueCopyImage = _libraries['libOpenCL.so.1'].clEnqueueCopyImage
    clEnqueueCopyImage.restype = cl_int
    clEnqueueCopyImage.argtypes = [cl_command_queue, cl_mem, cl_mem, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueCopyImageToBuffer = _libraries['libOpenCL.so.1'].clEnqueueCopyImageToBuffer
    clEnqueueCopyImageToBuffer.restype = cl_int
    clEnqueueCopyImageToBuffer.argtypes = [cl_command_queue, cl_mem, cl_mem, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueCopyBufferToImage = _libraries['libOpenCL.so.1'].clEnqueueCopyBufferToImage
    clEnqueueCopyBufferToImage.restype = cl_int
    clEnqueueCopyBufferToImage.argtypes = [cl_command_queue, cl_mem, cl_mem, size_t, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueMapBuffer = _libraries['libOpenCL.so.1'].clEnqueueMapBuffer
    clEnqueueMapBuffer.restype = ctypes.POINTER(None)
    clEnqueueMapBuffer.argtypes = [cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clEnqueueMapImage = _libraries['libOpenCL.so.1'].clEnqueueMapImage
    clEnqueueMapImage.restype = ctypes.POINTER(None)
    clEnqueueMapImage.argtypes = [cl_command_queue, cl_mem, cl_bool, cl_map_flags, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clEnqueueUnmapMemObject = _libraries['libOpenCL.so.1'].clEnqueueUnmapMemObject
    clEnqueueUnmapMemObject.restype = cl_int
    clEnqueueUnmapMemObject.argtypes = [cl_command_queue, cl_mem, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueMigrateMemObjects = _libraries['libOpenCL.so.1'].clEnqueueMigrateMemObjects
    clEnqueueMigrateMemObjects.restype = cl_int
    clEnqueueMigrateMemObjects.argtypes = [cl_command_queue, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_mem)), cl_mem_migration_flags, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueNDRangeKernel = _libraries['libOpenCL.so.1'].clEnqueueNDRangeKernel
    clEnqueueNDRangeKernel.restype = cl_int
    clEnqueueNDRangeKernel.argtypes = [cl_command_queue, cl_kernel, cl_uint, ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueNativeKernel = _libraries['libOpenCL.so.1'].clEnqueueNativeKernel
    clEnqueueNativeKernel.restype = cl_int
    clEnqueueNativeKernel.argtypes = [cl_command_queue, ctypes.CFUNCTYPE(None, ctypes.POINTER(None)), ctypes.POINTER(None), size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_mem)), ctypes.POINTER(ctypes.POINTER(None)), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueMarkerWithWaitList = _libraries['libOpenCL.so.1'].clEnqueueMarkerWithWaitList
    clEnqueueMarkerWithWaitList.restype = cl_int
    clEnqueueMarkerWithWaitList.argtypes = [cl_command_queue, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueBarrierWithWaitList = _libraries['libOpenCL.so.1'].clEnqueueBarrierWithWaitList
    clEnqueueBarrierWithWaitList.restype = cl_int
    clEnqueueBarrierWithWaitList.argtypes = [cl_command_queue, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueSVMFree = _libraries['libOpenCL.so.1'].clEnqueueSVMFree
    clEnqueueSVMFree.restype = cl_int
    clEnqueueSVMFree.argtypes = [cl_command_queue, cl_uint, ctypes.POINTER(None) * 0, ctypes.CFUNCTYPE(None, ctypes.POINTER(struct__cl_command_queue), ctypes.c_uint32, ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(None)), ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueSVMMemcpy = _libraries['libOpenCL.so.1'].clEnqueueSVMMemcpy
    clEnqueueSVMMemcpy.restype = cl_int
    clEnqueueSVMMemcpy.argtypes = [cl_command_queue, cl_bool, ctypes.POINTER(None), ctypes.POINTER(None), size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueSVMMemFill = _libraries['libOpenCL.so.1'].clEnqueueSVMMemFill
    clEnqueueSVMMemFill.restype = cl_int
    clEnqueueSVMMemFill.argtypes = [cl_command_queue, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueSVMMap = _libraries['libOpenCL.so.1'].clEnqueueSVMMap
    clEnqueueSVMMap.restype = cl_int
    clEnqueueSVMMap.argtypes = [cl_command_queue, cl_bool, cl_map_flags, ctypes.POINTER(None), size_t, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueSVMUnmap = _libraries['libOpenCL.so.1'].clEnqueueSVMUnmap
    clEnqueueSVMUnmap.restype = cl_int
    clEnqueueSVMUnmap.argtypes = [cl_command_queue, ctypes.POINTER(None), cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueSVMMigrateMem = _libraries['libOpenCL.so.1'].clEnqueueSVMMigrateMem
    clEnqueueSVMMigrateMem.restype = cl_int
    clEnqueueSVMMigrateMem.argtypes = [cl_command_queue, cl_uint, ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), cl_mem_migration_flags, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clGetExtensionFunctionAddressForPlatform = _libraries['libOpenCL.so.1'].clGetExtensionFunctionAddressForPlatform
    clGetExtensionFunctionAddressForPlatform.restype = ctypes.POINTER(None)
    clGetExtensionFunctionAddressForPlatform.argtypes = [cl_platform_id, ctypes.POINTER(ctypes.c_char)]
except AttributeError:
    pass
try:
    clCreateImage2D = _libraries['libOpenCL.so.1'].clCreateImage2D
    clCreateImage2D.restype = cl_mem
    clCreateImage2D.argtypes = [cl_context, cl_mem_flags, ctypes.POINTER(struct__cl_image_format), size_t, size_t, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateImage3D = _libraries['libOpenCL.so.1'].clCreateImage3D
    clCreateImage3D.restype = cl_mem
    clCreateImage3D.argtypes = [cl_context, cl_mem_flags, ctypes.POINTER(struct__cl_image_format), size_t, size_t, size_t, size_t, size_t, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clEnqueueMarker = _libraries['libOpenCL.so.1'].clEnqueueMarker
    clEnqueueMarker.restype = cl_int
    clEnqueueMarker.argtypes = [cl_command_queue, ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueWaitForEvents = _libraries['libOpenCL.so.1'].clEnqueueWaitForEvents
    clEnqueueWaitForEvents.restype = cl_int
    clEnqueueWaitForEvents.argtypes = [cl_command_queue, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
try:
    clEnqueueBarrier = _libraries['libOpenCL.so.1'].clEnqueueBarrier
    clEnqueueBarrier.restype = cl_int
    clEnqueueBarrier.argtypes = [cl_command_queue]
except AttributeError:
    pass
try:
    clUnloadCompiler = _libraries['libOpenCL.so.1'].clUnloadCompiler
    clUnloadCompiler.restype = cl_int
    clUnloadCompiler.argtypes = []
except AttributeError:
    pass
try:
    clGetExtensionFunctionAddress = _libraries['libOpenCL.so.1'].clGetExtensionFunctionAddress
    clGetExtensionFunctionAddress.restype = ctypes.POINTER(None)
    clGetExtensionFunctionAddress.argtypes = [ctypes.POINTER(ctypes.c_char)]
except AttributeError:
    pass
try:
    clCreateCommandQueue = _libraries['libOpenCL.so.1'].clCreateCommandQueue
    clCreateCommandQueue.restype = cl_command_queue
    clCreateCommandQueue.argtypes = [cl_context, cl_device_id, cl_command_queue_properties, ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clCreateSampler = _libraries['libOpenCL.so.1'].clCreateSampler
    clCreateSampler.restype = cl_sampler
    clCreateSampler.argtypes = [cl_context, cl_bool, cl_addressing_mode, cl_filter_mode, ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
    pass
try:
    clEnqueueTask = _libraries['libOpenCL.so.1'].clEnqueueTask
    clEnqueueTask.restype = cl_int
    clEnqueueTask.argtypes = [cl_command_queue, cl_kernel, cl_uint, ctypes.POINTER(ctypes.POINTER(struct__cl_event)), ctypes.POINTER(ctypes.POINTER(struct__cl_event))]
except AttributeError:
    pass
__all__ = \
    ['CL_A', 'CL_ABGR', 'CL_ADDRESS_CLAMP',
    'CL_ADDRESS_CLAMP_TO_EDGE', 'CL_ADDRESS_MIRRORED_REPEAT',
    'CL_ADDRESS_NONE', 'CL_ADDRESS_REPEAT', 'CL_ARGB', 'CL_BGRA',
    'CL_BLOCKING', 'CL_BUFFER_CREATE_TYPE_REGION', 'CL_BUILD_ERROR',
    'CL_BUILD_IN_PROGRESS', 'CL_BUILD_NONE',
    'CL_BUILD_PROGRAM_FAILURE', 'CL_BUILD_SUCCESS',
    'CL_COMMAND_ACQUIRE_GL_OBJECTS', 'CL_COMMAND_BARRIER',
    'CL_COMMAND_COPY_BUFFER', 'CL_COMMAND_COPY_BUFFER_RECT',
    'CL_COMMAND_COPY_BUFFER_TO_IMAGE', 'CL_COMMAND_COPY_IMAGE',
    'CL_COMMAND_COPY_IMAGE_TO_BUFFER', 'CL_COMMAND_FILL_BUFFER',
    'CL_COMMAND_FILL_IMAGE', 'CL_COMMAND_MAP_BUFFER',
    'CL_COMMAND_MAP_IMAGE', 'CL_COMMAND_MARKER',
    'CL_COMMAND_MIGRATE_MEM_OBJECTS', 'CL_COMMAND_NATIVE_KERNEL',
    'CL_COMMAND_NDRANGE_KERNEL', 'CL_COMMAND_READ_BUFFER',
    'CL_COMMAND_READ_BUFFER_RECT', 'CL_COMMAND_READ_IMAGE',
    'CL_COMMAND_RELEASE_GL_OBJECTS', 'CL_COMMAND_SVM_FREE',
    'CL_COMMAND_SVM_MAP', 'CL_COMMAND_SVM_MEMCPY',
    'CL_COMMAND_SVM_MEMFILL', 'CL_COMMAND_SVM_MIGRATE_MEM',
    'CL_COMMAND_SVM_UNMAP', 'CL_COMMAND_TASK',
    'CL_COMMAND_UNMAP_MEM_OBJECT', 'CL_COMMAND_USER',
    'CL_COMMAND_WRITE_BUFFER', 'CL_COMMAND_WRITE_BUFFER_RECT',
    'CL_COMMAND_WRITE_IMAGE', 'CL_COMPILER_NOT_AVAILABLE',
    'CL_COMPILE_PROGRAM_FAILURE', 'CL_COMPLETE', 'CL_CONTEXT_DEVICES',
    'CL_CONTEXT_INTEROP_USER_SYNC', 'CL_CONTEXT_NUM_DEVICES',
    'CL_CONTEXT_PLATFORM', 'CL_CONTEXT_PROPERTIES',
    'CL_CONTEXT_REFERENCE_COUNT', 'CL_DEPTH', 'CL_DEPTH_STENCIL',
    'CL_DEVICE_ADDRESS_BITS', 'CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE',
    'CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE',
    'CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE',
    'CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE',
    'CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE',
    'CL_DEVICE_AFFINITY_DOMAIN_NUMA',
    'CL_DEVICE_ATOMIC_FENCE_CAPABILITIES',
    'CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES',
    'CL_DEVICE_ATOMIC_ORDER_ACQ_REL',
    'CL_DEVICE_ATOMIC_ORDER_RELAXED',
    'CL_DEVICE_ATOMIC_ORDER_SEQ_CST',
    'CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES',
    'CL_DEVICE_ATOMIC_SCOPE_DEVICE',
    'CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP',
    'CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM', 'CL_DEVICE_AVAILABLE',
    'CL_DEVICE_BUILT_IN_KERNELS',
    'CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION',
    'CL_DEVICE_COMPILER_AVAILABLE',
    'CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES',
    'CL_DEVICE_DOUBLE_FP_CONFIG', 'CL_DEVICE_ENDIAN_LITTLE',
    'CL_DEVICE_ERROR_CORRECTION_SUPPORT',
    'CL_DEVICE_EXECUTION_CAPABILITIES', 'CL_DEVICE_EXTENSIONS',
    'CL_DEVICE_EXTENSIONS_WITH_VERSION',
    'CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT',
    'CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE',
    'CL_DEVICE_GLOBAL_MEM_CACHE_SIZE',
    'CL_DEVICE_GLOBAL_MEM_CACHE_TYPE', 'CL_DEVICE_GLOBAL_MEM_SIZE',
    'CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE',
    'CL_DEVICE_HOST_UNIFIED_MEMORY', 'CL_DEVICE_ILS_WITH_VERSION',
    'CL_DEVICE_IL_VERSION', 'CL_DEVICE_IMAGE2D_MAX_HEIGHT',
    'CL_DEVICE_IMAGE2D_MAX_WIDTH', 'CL_DEVICE_IMAGE3D_MAX_DEPTH',
    'CL_DEVICE_IMAGE3D_MAX_HEIGHT', 'CL_DEVICE_IMAGE3D_MAX_WIDTH',
    'CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT',
    'CL_DEVICE_IMAGE_MAX_ARRAY_SIZE',
    'CL_DEVICE_IMAGE_MAX_BUFFER_SIZE',
    'CL_DEVICE_IMAGE_PITCH_ALIGNMENT', 'CL_DEVICE_IMAGE_SUPPORT',
    'CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED',
    'CL_DEVICE_LINKER_AVAILABLE', 'CL_DEVICE_LOCAL_MEM_SIZE',
    'CL_DEVICE_LOCAL_MEM_TYPE', 'CL_DEVICE_MAX_CLOCK_FREQUENCY',
    'CL_DEVICE_MAX_COMPUTE_UNITS', 'CL_DEVICE_MAX_CONSTANT_ARGS',
    'CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE',
    'CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE',
    'CL_DEVICE_MAX_MEM_ALLOC_SIZE', 'CL_DEVICE_MAX_NUM_SUB_GROUPS',
    'CL_DEVICE_MAX_ON_DEVICE_EVENTS',
    'CL_DEVICE_MAX_ON_DEVICE_QUEUES', 'CL_DEVICE_MAX_PARAMETER_SIZE',
    'CL_DEVICE_MAX_PIPE_ARGS', 'CL_DEVICE_MAX_READ_IMAGE_ARGS',
    'CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS', 'CL_DEVICE_MAX_SAMPLERS',
    'CL_DEVICE_MAX_WORK_GROUP_SIZE',
    'CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS',
    'CL_DEVICE_MAX_WORK_ITEM_SIZES', 'CL_DEVICE_MAX_WRITE_IMAGE_ARGS',
    'CL_DEVICE_MEM_BASE_ADDR_ALIGN',
    'CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE', 'CL_DEVICE_NAME',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_INT',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG',
    'CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT',
    'CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT',
    'CL_DEVICE_NOT_AVAILABLE', 'CL_DEVICE_NOT_FOUND',
    'CL_DEVICE_NUMERIC_VERSION', 'CL_DEVICE_OPENCL_C_ALL_VERSIONS',
    'CL_DEVICE_OPENCL_C_FEATURES', 'CL_DEVICE_OPENCL_C_VERSION',
    'CL_DEVICE_PARENT_DEVICE', 'CL_DEVICE_PARTITION_AFFINITY_DOMAIN',
    'CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN',
    'CL_DEVICE_PARTITION_BY_COUNTS',
    'CL_DEVICE_PARTITION_BY_COUNTS_LIST_END',
    'CL_DEVICE_PARTITION_EQUALLY', 'CL_DEVICE_PARTITION_FAILED',
    'CL_DEVICE_PARTITION_MAX_SUB_DEVICES',
    'CL_DEVICE_PARTITION_PROPERTIES', 'CL_DEVICE_PARTITION_TYPE',
    'CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS',
    'CL_DEVICE_PIPE_MAX_PACKET_SIZE', 'CL_DEVICE_PIPE_SUPPORT',
    'CL_DEVICE_PLATFORM',
    'CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT',
    'CL_DEVICE_PREFERRED_INTEROP_USER_SYNC',
    'CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT',
    'CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG',
    'CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT',
    'CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE',
    'CL_DEVICE_PRINTF_BUFFER_SIZE', 'CL_DEVICE_PROFILE',
    'CL_DEVICE_PROFILING_TIMER_RESOLUTION',
    'CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE',
    'CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE',
    'CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES',
    'CL_DEVICE_QUEUE_ON_HOST_PROPERTIES',
    'CL_DEVICE_QUEUE_PROPERTIES',
    'CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT',
    'CL_DEVICE_QUEUE_SUPPORTED', 'CL_DEVICE_REFERENCE_COUNT',
    'CL_DEVICE_SINGLE_FP_CONFIG',
    'CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS',
    'CL_DEVICE_SVM_ATOMICS', 'CL_DEVICE_SVM_CAPABILITIES',
    'CL_DEVICE_SVM_COARSE_GRAIN_BUFFER',
    'CL_DEVICE_SVM_FINE_GRAIN_BUFFER',
    'CL_DEVICE_SVM_FINE_GRAIN_SYSTEM', 'CL_DEVICE_TYPE',
    'CL_DEVICE_TYPE_ACCELERATOR', 'CL_DEVICE_TYPE_ALL',
    'CL_DEVICE_TYPE_CPU', 'CL_DEVICE_TYPE_CUSTOM',
    'CL_DEVICE_TYPE_DEFAULT', 'CL_DEVICE_TYPE_GPU',
    'CL_DEVICE_VENDOR', 'CL_DEVICE_VENDOR_ID', 'CL_DEVICE_VERSION',
    'CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT',
    'CL_DRIVER_VERSION', 'CL_EVENT_COMMAND_EXECUTION_STATUS',
    'CL_EVENT_COMMAND_QUEUE', 'CL_EVENT_COMMAND_TYPE',
    'CL_EVENT_CONTEXT', 'CL_EVENT_REFERENCE_COUNT', 'CL_EXEC_KERNEL',
    'CL_EXEC_NATIVE_KERNEL',
    'CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST', 'CL_FALSE',
    'CL_FILTER_LINEAR', 'CL_FILTER_NEAREST', 'CL_FLOAT',
    'CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT', 'CL_FP_DENORM',
    'CL_FP_FMA', 'CL_FP_INF_NAN', 'CL_FP_ROUND_TO_INF',
    'CL_FP_ROUND_TO_NEAREST', 'CL_FP_ROUND_TO_ZERO',
    'CL_FP_SOFT_FLOAT', 'CL_GLOBAL', 'CL_HALF_FLOAT',
    'CL_IMAGE_ARRAY_SIZE', 'CL_IMAGE_BUFFER', 'CL_IMAGE_DEPTH',
    'CL_IMAGE_ELEMENT_SIZE', 'CL_IMAGE_FORMAT',
    'CL_IMAGE_FORMAT_MISMATCH', 'CL_IMAGE_FORMAT_NOT_SUPPORTED',
    'CL_IMAGE_HEIGHT', 'CL_IMAGE_NUM_MIP_LEVELS',
    'CL_IMAGE_NUM_SAMPLES', 'CL_IMAGE_ROW_PITCH',
    'CL_IMAGE_SLICE_PITCH', 'CL_IMAGE_WIDTH', 'CL_INTENSITY',
    'CL_INVALID_ARG_INDEX', 'CL_INVALID_ARG_SIZE',
    'CL_INVALID_ARG_VALUE', 'CL_INVALID_BINARY',
    'CL_INVALID_BUFFER_SIZE', 'CL_INVALID_BUILD_OPTIONS',
    'CL_INVALID_COMMAND_QUEUE', 'CL_INVALID_COMPILER_OPTIONS',
    'CL_INVALID_CONTEXT', 'CL_INVALID_DEVICE',
    'CL_INVALID_DEVICE_PARTITION_COUNT', 'CL_INVALID_DEVICE_QUEUE',
    'CL_INVALID_DEVICE_TYPE', 'CL_INVALID_EVENT',
    'CL_INVALID_EVENT_WAIT_LIST', 'CL_INVALID_GLOBAL_OFFSET',
    'CL_INVALID_GLOBAL_WORK_SIZE', 'CL_INVALID_GL_OBJECT',
    'CL_INVALID_HOST_PTR', 'CL_INVALID_IMAGE_DESCRIPTOR',
    'CL_INVALID_IMAGE_FORMAT_DESCRIPTOR', 'CL_INVALID_IMAGE_SIZE',
    'CL_INVALID_KERNEL', 'CL_INVALID_KERNEL_ARGS',
    'CL_INVALID_KERNEL_DEFINITION', 'CL_INVALID_KERNEL_NAME',
    'CL_INVALID_LINKER_OPTIONS', 'CL_INVALID_MEM_OBJECT',
    'CL_INVALID_MIP_LEVEL', 'CL_INVALID_OPERATION',
    'CL_INVALID_PIPE_SIZE', 'CL_INVALID_PLATFORM',
    'CL_INVALID_PROGRAM', 'CL_INVALID_PROGRAM_EXECUTABLE',
    'CL_INVALID_PROPERTY', 'CL_INVALID_QUEUE_PROPERTIES',
    'CL_INVALID_SAMPLER', 'CL_INVALID_SPEC_ID', 'CL_INVALID_VALUE',
    'CL_INVALID_WORK_DIMENSION', 'CL_INVALID_WORK_GROUP_SIZE',
    'CL_INVALID_WORK_ITEM_SIZE', 'CL_KERNEL_ARG_ACCESS_NONE',
    'CL_KERNEL_ARG_ACCESS_QUALIFIER',
    'CL_KERNEL_ARG_ACCESS_READ_ONLY',
    'CL_KERNEL_ARG_ACCESS_READ_WRITE',
    'CL_KERNEL_ARG_ACCESS_WRITE_ONLY',
    'CL_KERNEL_ARG_ADDRESS_CONSTANT', 'CL_KERNEL_ARG_ADDRESS_GLOBAL',
    'CL_KERNEL_ARG_ADDRESS_LOCAL', 'CL_KERNEL_ARG_ADDRESS_PRIVATE',
    'CL_KERNEL_ARG_ADDRESS_QUALIFIER',
    'CL_KERNEL_ARG_INFO_NOT_AVAILABLE', 'CL_KERNEL_ARG_NAME',
    'CL_KERNEL_ARG_TYPE_CONST', 'CL_KERNEL_ARG_TYPE_NAME',
    'CL_KERNEL_ARG_TYPE_NONE', 'CL_KERNEL_ARG_TYPE_PIPE',
    'CL_KERNEL_ARG_TYPE_QUALIFIER', 'CL_KERNEL_ARG_TYPE_RESTRICT',
    'CL_KERNEL_ARG_TYPE_VOLATILE', 'CL_KERNEL_ATTRIBUTES',
    'CL_KERNEL_COMPILE_NUM_SUB_GROUPS',
    'CL_KERNEL_COMPILE_WORK_GROUP_SIZE', 'CL_KERNEL_CONTEXT',
    'CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM',
    'CL_KERNEL_EXEC_INFO_SVM_PTRS', 'CL_KERNEL_FUNCTION_NAME',
    'CL_KERNEL_GLOBAL_WORK_SIZE', 'CL_KERNEL_LOCAL_MEM_SIZE',
    'CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT',
    'CL_KERNEL_MAX_NUM_SUB_GROUPS',
    'CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE', 'CL_KERNEL_NUM_ARGS',
    'CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE',
    'CL_KERNEL_PRIVATE_MEM_SIZE', 'CL_KERNEL_PROGRAM',
    'CL_KERNEL_REFERENCE_COUNT',
    'CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE',
    'CL_KERNEL_WORK_GROUP_SIZE', 'CL_KHRONOS_VENDOR_ID_CODEPLAY',
    'CL_LINKER_NOT_AVAILABLE', 'CL_LINK_PROGRAM_FAILURE', 'CL_LOCAL',
    'CL_LUMINANCE', 'CL_MAP_FAILURE', 'CL_MAP_READ', 'CL_MAP_WRITE',
    'CL_MAP_WRITE_INVALIDATE_REGION',
    'CL_MAX_SIZE_RESTRICTION_EXCEEDED', 'CL_MEM_ALLOC_HOST_PTR',
    'CL_MEM_ASSOCIATED_MEMOBJECT', 'CL_MEM_CONTEXT',
    'CL_MEM_COPY_HOST_PTR', 'CL_MEM_COPY_OVERLAP', 'CL_MEM_FLAGS',
    'CL_MEM_HOST_NO_ACCESS', 'CL_MEM_HOST_PTR',
    'CL_MEM_HOST_READ_ONLY', 'CL_MEM_HOST_WRITE_ONLY',
    'CL_MEM_KERNEL_READ_AND_WRITE', 'CL_MEM_MAP_COUNT',
    'CL_MEM_OBJECT_ALLOCATION_FAILURE', 'CL_MEM_OBJECT_BUFFER',
    'CL_MEM_OBJECT_IMAGE1D', 'CL_MEM_OBJECT_IMAGE1D_ARRAY',
    'CL_MEM_OBJECT_IMAGE1D_BUFFER', 'CL_MEM_OBJECT_IMAGE2D',
    'CL_MEM_OBJECT_IMAGE2D_ARRAY', 'CL_MEM_OBJECT_IMAGE3D',
    'CL_MEM_OBJECT_PIPE', 'CL_MEM_OFFSET', 'CL_MEM_PROPERTIES',
    'CL_MEM_READ_ONLY', 'CL_MEM_READ_WRITE', 'CL_MEM_REFERENCE_COUNT',
    'CL_MEM_SIZE', 'CL_MEM_SVM_ATOMICS',
    'CL_MEM_SVM_FINE_GRAIN_BUFFER', 'CL_MEM_TYPE',
    'CL_MEM_USES_SVM_POINTER', 'CL_MEM_USE_HOST_PTR',
    'CL_MEM_WRITE_ONLY', 'CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED',
    'CL_MIGRATE_MEM_OBJECT_HOST', 'CL_MISALIGNED_SUB_BUFFER_OFFSET',
    'CL_NAME_VERSION_MAX_NAME_SIZE', 'CL_NONE', 'CL_NON_BLOCKING',
    'CL_OUT_OF_HOST_MEMORY', 'CL_OUT_OF_RESOURCES',
    'CL_PIPE_MAX_PACKETS', 'CL_PIPE_PACKET_SIZE',
    'CL_PIPE_PROPERTIES', 'CL_PLATFORM_EXTENSIONS',
    'CL_PLATFORM_EXTENSIONS_WITH_VERSION',
    'CL_PLATFORM_HOST_TIMER_RESOLUTION', 'CL_PLATFORM_NAME',
    'CL_PLATFORM_NUMERIC_VERSION', 'CL_PLATFORM_PROFILE',
    'CL_PLATFORM_VENDOR', 'CL_PLATFORM_VERSION',
    'CL_PROFILING_COMMAND_COMPLETE', 'CL_PROFILING_COMMAND_END',
    'CL_PROFILING_COMMAND_QUEUED', 'CL_PROFILING_COMMAND_START',
    'CL_PROFILING_COMMAND_SUBMIT', 'CL_PROFILING_INFO_NOT_AVAILABLE',
    'CL_PROGRAM_BINARIES', 'CL_PROGRAM_BINARY_SIZES',
    'CL_PROGRAM_BINARY_TYPE',
    'CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT',
    'CL_PROGRAM_BINARY_TYPE_EXECUTABLE',
    'CL_PROGRAM_BINARY_TYPE_LIBRARY', 'CL_PROGRAM_BINARY_TYPE_NONE',
    'CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE',
    'CL_PROGRAM_BUILD_LOG', 'CL_PROGRAM_BUILD_OPTIONS',
    'CL_PROGRAM_BUILD_STATUS', 'CL_PROGRAM_CONTEXT',
    'CL_PROGRAM_DEVICES', 'CL_PROGRAM_IL', 'CL_PROGRAM_KERNEL_NAMES',
    'CL_PROGRAM_NUM_DEVICES', 'CL_PROGRAM_NUM_KERNELS',
    'CL_PROGRAM_REFERENCE_COUNT',
    'CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT',
    'CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT', 'CL_PROGRAM_SOURCE',
    'CL_QUEUED', 'CL_QUEUE_CONTEXT', 'CL_QUEUE_DEVICE',
    'CL_QUEUE_DEVICE_DEFAULT', 'CL_QUEUE_ON_DEVICE',
    'CL_QUEUE_ON_DEVICE_DEFAULT',
    'CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE',
    'CL_QUEUE_PROFILING_ENABLE', 'CL_QUEUE_PROPERTIES',
    'CL_QUEUE_PROPERTIES_ARRAY', 'CL_QUEUE_REFERENCE_COUNT',
    'CL_QUEUE_SIZE', 'CL_R', 'CL_RA', 'CL_READ_ONLY_CACHE',
    'CL_READ_WRITE_CACHE', 'CL_RG', 'CL_RGB', 'CL_RGBA', 'CL_RGBx',
    'CL_RGx', 'CL_RUNNING', 'CL_Rx', 'CL_SAMPLER_ADDRESSING_MODE',
    'CL_SAMPLER_CONTEXT', 'CL_SAMPLER_FILTER_MODE',
    'CL_SAMPLER_LOD_MAX', 'CL_SAMPLER_LOD_MIN',
    'CL_SAMPLER_MIP_FILTER_MODE', 'CL_SAMPLER_NORMALIZED_COORDS',
    'CL_SAMPLER_PROPERTIES', 'CL_SAMPLER_REFERENCE_COUNT',
    'CL_SIGNED_INT16', 'CL_SIGNED_INT32', 'CL_SIGNED_INT8',
    'CL_SNORM_INT16', 'CL_SNORM_INT8', 'CL_SUBMITTED', 'CL_SUCCESS',
    'CL_TRUE', 'CL_UNORM_INT16', 'CL_UNORM_INT24', 'CL_UNORM_INT8',
    'CL_UNORM_INT_101010', 'CL_UNORM_INT_101010_2',
    'CL_UNORM_SHORT_555', 'CL_UNORM_SHORT_565', 'CL_UNSIGNED_INT16',
    'CL_UNSIGNED_INT32', 'CL_UNSIGNED_INT8', 'CL_VERSION_MAJOR_BITS',
    'CL_VERSION_MAJOR_MASK', 'CL_VERSION_MINOR_BITS',
    'CL_VERSION_MINOR_MASK', 'CL_VERSION_PATCH_BITS',
    'CL_VERSION_PATCH_MASK', 'CL_sBGRA', 'CL_sRGB', 'CL_sRGBA',
    'CL_sRGBx', '__OPENCL_CL_H', 'clBuildProgram', 'clCloneKernel',
    'clCompileProgram', 'clCreateBuffer',
    'clCreateBufferWithProperties', 'clCreateCommandQueue',
    'clCreateCommandQueueWithProperties', 'clCreateContext',
    'clCreateContextFromType', 'clCreateImage', 'clCreateImage2D',
    'clCreateImage3D', 'clCreateImageWithProperties',
    'clCreateKernel', 'clCreateKernelsInProgram', 'clCreatePipe',
    'clCreateProgramWithBinary', 'clCreateProgramWithBuiltInKernels',
    'clCreateProgramWithIL', 'clCreateProgramWithSource',
    'clCreateSampler', 'clCreateSamplerWithProperties',
    'clCreateSubBuffer', 'clCreateSubDevices', 'clCreateUserEvent',
    'clEnqueueBarrier', 'clEnqueueBarrierWithWaitList',
    'clEnqueueCopyBuffer', 'clEnqueueCopyBufferRect',
    'clEnqueueCopyBufferToImage', 'clEnqueueCopyImage',
    'clEnqueueCopyImageToBuffer', 'clEnqueueFillBuffer',
    'clEnqueueFillImage', 'clEnqueueMapBuffer', 'clEnqueueMapImage',
    'clEnqueueMarker', 'clEnqueueMarkerWithWaitList',
    'clEnqueueMigrateMemObjects', 'clEnqueueNDRangeKernel',
    'clEnqueueNativeKernel', 'clEnqueueReadBuffer',
    'clEnqueueReadBufferRect', 'clEnqueueReadImage',
    'clEnqueueSVMFree', 'clEnqueueSVMMap', 'clEnqueueSVMMemFill',
    'clEnqueueSVMMemcpy', 'clEnqueueSVMMigrateMem',
    'clEnqueueSVMUnmap', 'clEnqueueTask', 'clEnqueueUnmapMemObject',
    'clEnqueueWaitForEvents', 'clEnqueueWriteBuffer',
    'clEnqueueWriteBufferRect', 'clEnqueueWriteImage', 'clFinish',
    'clFlush', 'clGetCommandQueueInfo', 'clGetContextInfo',
    'clGetDeviceAndHostTimer', 'clGetDeviceIDs', 'clGetDeviceInfo',
    'clGetEventInfo', 'clGetEventProfilingInfo',
    'clGetExtensionFunctionAddress',
    'clGetExtensionFunctionAddressForPlatform', 'clGetHostTimer',
    'clGetImageInfo', 'clGetKernelArgInfo', 'clGetKernelInfo',
    'clGetKernelSubGroupInfo', 'clGetKernelWorkGroupInfo',
    'clGetMemObjectInfo', 'clGetPipeInfo', 'clGetPlatformIDs',
    'clGetPlatformInfo', 'clGetProgramBuildInfo', 'clGetProgramInfo',
    'clGetSamplerInfo', 'clGetSupportedImageFormats', 'clLinkProgram',
    'clReleaseCommandQueue', 'clReleaseContext', 'clReleaseDevice',
    'clReleaseEvent', 'clReleaseKernel', 'clReleaseMemObject',
    'clReleaseProgram', 'clReleaseSampler', 'clRetainCommandQueue',
    'clRetainContext', 'clRetainDevice', 'clRetainEvent',
    'clRetainKernel', 'clRetainMemObject', 'clRetainProgram',
    'clRetainSampler', 'clSVMAlloc', 'clSVMFree',
    'clSetContextDestructorCallback',
    'clSetDefaultDeviceCommandQueue', 'clSetEventCallback',
    'clSetKernelArg', 'clSetKernelArgSVMPointer',
    'clSetKernelExecInfo', 'clSetMemObjectDestructorCallback',
    'clSetProgramReleaseCallback',
    'clSetProgramSpecializationConstant', 'clSetUserEventStatus',
    'clUnloadCompiler', 'clUnloadPlatformCompiler', 'clWaitForEvents',
    'cl_addressing_mode', 'cl_bitfield', 'cl_bool',
    'cl_buffer_create_type', 'cl_buffer_region', 'cl_build_status',
    'cl_channel_order', 'cl_channel_type', 'cl_command_queue',
    'cl_command_queue_info', 'cl_command_queue_properties',
    'cl_command_type', 'cl_context', 'cl_context_info',
    'cl_context_properties', 'cl_device_affinity_domain',
    'cl_device_atomic_capabilities',
    'cl_device_device_enqueue_capabilities',
    'cl_device_exec_capabilities', 'cl_device_fp_config',
    'cl_device_id', 'cl_device_info', 'cl_device_local_mem_type',
    'cl_device_mem_cache_type', 'cl_device_partition_property',
    'cl_device_svm_capabilities', 'cl_device_type', 'cl_event',
    'cl_event_info', 'cl_filter_mode', 'cl_image_desc',
    'cl_image_format', 'cl_image_info', 'cl_int', 'cl_kernel',
    'cl_kernel_arg_access_qualifier',
    'cl_kernel_arg_address_qualifier', 'cl_kernel_arg_info',
    'cl_kernel_arg_type_qualifier', 'cl_kernel_exec_info',
    'cl_kernel_info', 'cl_kernel_sub_group_info',
    'cl_kernel_work_group_info', 'cl_khronos_vendor_id',
    'cl_map_flags', 'cl_mem', 'cl_mem_flags', 'cl_mem_info',
    'cl_mem_migration_flags', 'cl_mem_object_type',
    'cl_mem_properties', 'cl_name_version', 'cl_pipe_info',
    'cl_pipe_properties', 'cl_platform_id', 'cl_platform_info',
    'cl_profiling_info', 'cl_program', 'cl_program_binary_type',
    'cl_program_build_info', 'cl_program_info', 'cl_properties',
    'cl_queue_properties', 'cl_sampler', 'cl_sampler_info',
    'cl_sampler_properties', 'cl_svm_mem_flags', 'cl_uint',
    'cl_version', 'size_t', 'struct__cl_buffer_region',
    'struct__cl_command_queue', 'struct__cl_context',
    'struct__cl_device_id', 'struct__cl_event',
    'struct__cl_image_desc', 'struct__cl_image_format',
    'struct__cl_kernel', 'struct__cl_mem', 'struct__cl_name_version',
    'struct__cl_platform_id', 'struct__cl_program',
    'struct__cl_sampler', 'union__cl_image_desc_0']