diff --git a/cuda_bindings/cuda/bindings/driver.pyx.in b/cuda_bindings/cuda/bindings/driver.pyx.in
index ee520598e..ad596616f 100644
--- a/cuda_bindings/cuda/bindings/driver.pyx.in
+++ b/cuda_bindings/cuda/bindings/driver.pyx.in
@@ -357,6 +357,8 @@ class CUipcMem_flags(IntEnum):
 
     #: Automatically enable peer access between remote devices as needed
     CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = cydriver.CUipcMem_flags_enum.CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS{{endif}}
+
+_dict_CUipcMem_flags = dict(((int(v), v) for k, v in CUipcMem_flags.__members__.items()))
 {{endif}}
 {{if 'CUmemAttach_flags_enum' in found_types}}
 
@@ -377,6 +379,8 @@ class CUmemAttach_flags(IntEnum):
     #: Memory can only be accessed by a single stream on the associated
     #: device
     CU_MEM_ATTACH_SINGLE = cydriver.CUmemAttach_flags_enum.CU_MEM_ATTACH_SINGLE{{endif}}
+
+_dict_CUmemAttach_flags = dict(((int(v), v) for k, v in CUmemAttach_flags.__members__.items()))
 {{endif}}
 {{if 'CUctx_flags_enum' in found_types}}
 
@@ -429,6 +433,8 @@ class CUctx_flags(IntEnum):
     CU_CTX_SYNC_MEMOPS = cydriver.CUctx_flags_enum.CU_CTX_SYNC_MEMOPS{{endif}}
     {{if 'CU_CTX_FLAGS_MASK' in found_values}}
     CU_CTX_FLAGS_MASK = cydriver.CUctx_flags_enum.CU_CTX_FLAGS_MASK{{endif}}
+
+_dict_CUctx_flags = dict(((int(v), v) for k, v in CUctx_flags.__members__.items()))
 {{endif}}
 {{if 'CUevent_sched_flags_enum' in found_types}}
 
@@ -452,6 +458,8 @@ class CUevent_sched_flags(IntEnum):
 
     #: Set blocking synchronization as default scheduling
     CU_EVENT_SCHED_BLOCKING_SYNC = cydriver.CUevent_sched_flags_enum.CU_EVENT_SCHED_BLOCKING_SYNC{{endif}}
+
+_dict_CUevent_sched_flags = dict(((int(v), v) for k, v in CUevent_sched_flags.__members__.items()))
 {{endif}}
 {{if 'cl_event_flags_enum' in found_types}}
 
@@ -475,6 +483,8 @@ class cl_event_flags(IntEnum):
 
     #: Set blocking synchronization as default scheduling
     NVCL_EVENT_SCHED_BLOCKING_SYNC = cydriver.cl_event_flags_enum.NVCL_EVENT_SCHED_BLOCKING_SYNC{{endif}}
+
+_dict_cl_event_flags = dict(((int(v), v) for k, v in cl_event_flags.__members__.items()))
 {{endif}}
 {{if 'cl_context_flags_enum' in found_types}}
 
@@ -498,6 +508,8 @@ class cl_context_flags(IntEnum):
 
     #: Set blocking synchronization as default scheduling
     NVCL_CTX_SCHED_BLOCKING_SYNC = cydriver.cl_context_flags_enum.NVCL_CTX_SCHED_BLOCKING_SYNC{{endif}}
+
+_dict_cl_context_flags = dict(((int(v), v) for k, v in cl_context_flags.__members__.items()))
 {{endif}}
 {{if 'CUstream_flags_enum' in found_types}}
 
@@ -513,6 +525,8 @@ class CUstream_flags(IntEnum):
 
     #: Stream does not synchronize with stream 0 (the NULL stream)
     CU_STREAM_NON_BLOCKING = cydriver.CUstream_flags_enum.CU_STREAM_NON_BLOCKING{{endif}}
+
+_dict_CUstream_flags = dict(((int(v), v) for k, v in CUstream_flags.__members__.items()))
 {{endif}}
 {{if 'CUevent_flags_enum' in found_types}}
 
@@ -537,6 +551,8 @@ class CUevent_flags(IntEnum):
     #: Event is suitable for interprocess use. CU_EVENT_DISABLE_TIMING must
     #: be set
     CU_EVENT_INTERPROCESS = cydriver.CUevent_flags_enum.CU_EVENT_INTERPROCESS{{endif}}
+
+_dict_CUevent_flags = dict(((int(v), v) for k, v in CUevent_flags.__members__.items()))
 {{endif}}
 {{if 'CUevent_record_flags_enum' in found_types}}
 
@@ -554,6 +570,8 @@ class CUevent_record_flags(IntEnum):
     #: the default behavior. This flag is invalid when used outside of
     #: capture.
     CU_EVENT_RECORD_EXTERNAL = cydriver.CUevent_record_flags_enum.CU_EVENT_RECORD_EXTERNAL{{endif}}
+
+_dict_CUevent_record_flags = dict(((int(v), v) for k, v in CUevent_record_flags.__members__.items()))
 {{endif}}
 {{if 'CUevent_wait_flags_enum' in found_types}}
 
@@ -570,6 +588,8 @@ class CUevent_wait_flags(IntEnum):
     #: When using stream capture, create an event wait node instead of the
     #: default behavior. This flag is invalid when used outside of capture.
     CU_EVENT_WAIT_EXTERNAL = cydriver.CUevent_wait_flags_enum.CU_EVENT_WAIT_EXTERNAL{{endif}}
+
+_dict_CUevent_wait_flags = dict(((int(v), v) for k, v in CUevent_wait_flags.__members__.items()))
 {{endif}}
 {{if 'CUstreamWaitValue_flags_enum' in found_types}}
 
@@ -611,6 +631,8 @@ class CUstreamWaitValue_flags(IntEnum):
     #: restricted to selected platforms and can be queried with
     #: :py:obj:`~.CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES`.
     CU_STREAM_WAIT_VALUE_FLUSH = cydriver.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_FLUSH{{endif}}
+
+_dict_CUstreamWaitValue_flags = dict(((int(v), v) for k, v in CUstreamWaitValue_flags.__members__.items()))
 {{endif}}
 {{if 'CUstreamWriteValue_flags_enum' in found_types}}
 
@@ -631,6 +653,8 @@ class CUstreamWriteValue_flags(IntEnum):
     #: is scoped to the stream rather than a CUDA thread. This flag is not
     #: supported in the v2 API.
     CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = cydriver.CUstreamWriteValue_flags_enum.CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER{{endif}}
+
+_dict_CUstreamWriteValue_flags = dict(((int(v), v) for k, v in CUstreamWriteValue_flags.__members__.items()))
 {{endif}}
 {{if 'CUstreamBatchMemOpType_enum' in found_types}}
 
@@ -663,6 +687,8 @@ class CUstreamBatchMemOpType(IntEnum):
 
     #: Insert a memory barrier of the specified type
     CU_STREAM_MEM_OP_BARRIER = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_BARRIER{{endif}}
+
+_dict_CUstreamBatchMemOpType = dict(((int(v), v) for k, v in CUstreamBatchMemOpType.__members__.items()))
 {{endif}}
 {{if 'CUstreamMemoryBarrier_flags_enum' in found_types}}
 
@@ -678,6 +704,8 @@ class CUstreamMemoryBarrier_flags(IntEnum):
 
     #: Limit memory barrier scope to the GPU.
     CU_STREAM_MEMORY_BARRIER_TYPE_GPU = cydriver.CUstreamMemoryBarrier_flags_enum.CU_STREAM_MEMORY_BARRIER_TYPE_GPU{{endif}}
+
+_dict_CUstreamMemoryBarrier_flags = dict(((int(v), v) for k, v in CUstreamMemoryBarrier_flags.__members__.items()))
 {{endif}}
 {{if 'CUoccupancy_flags_enum' in found_types}}
 
@@ -694,6 +722,8 @@ class CUoccupancy_flags(IntEnum):
     #: Assume global caching is enabled and cannot be automatically turned
     #: off
     CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = cydriver.CUoccupancy_flags_enum.CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE{{endif}}
+
+_dict_CUoccupancy_flags = dict(((int(v), v) for k, v in CUoccupancy_flags.__members__.items()))
 {{endif}}
 {{if 'CUstreamUpdateCaptureDependencies_flags_enum' in found_types}}
 
@@ -709,6 +739,8 @@ class CUstreamUpdateCaptureDependencies_flags(IntEnum):
 
     #: Replace the dependency set with the new nodes
     CU_STREAM_SET_CAPTURE_DEPENDENCIES = cydriver.CUstreamUpdateCaptureDependencies_flags_enum.CU_STREAM_SET_CAPTURE_DEPENDENCIES{{endif}}
+
+_dict_CUstreamUpdateCaptureDependencies_flags = dict(((int(v), v) for k, v in CUstreamUpdateCaptureDependencies_flags.__members__.items()))
 {{endif}}
 {{if 'CUasyncNotificationType_enum' in found_types}}
 
@@ -718,6 +750,8 @@ class CUasyncNotificationType(IntEnum):
     """
     {{if 'CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET' in found_values}}
     CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET = cydriver.CUasyncNotificationType_enum.CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET{{endif}}
+
+_dict_CUasyncNotificationType = dict(((int(v), v) for k, v in CUasyncNotificationType.__members__.items()))
 {{endif}}
 {{if 'CUarray_format_enum' in found_types}}
 
@@ -945,6 +979,8 @@ class CUarray_format(IntEnum):
     CU_AD_FORMAT_SNORM_INT16X4 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X4{{endif}}
     {{if 'CU_AD_FORMAT_MAX' in found_values}}
     CU_AD_FORMAT_MAX = cydriver.CUarray_format_enum.CU_AD_FORMAT_MAX{{endif}}
+
+_dict_CUarray_format = dict(((int(v), v) for k, v in CUarray_format.__members__.items()))
 {{endif}}
 {{if 'CUaddress_mode_enum' in found_types}}
 
@@ -968,6 +1004,8 @@ class CUaddress_mode(IntEnum):
 
     #: Border address mode
     CU_TR_ADDRESS_MODE_BORDER = cydriver.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_BORDER{{endif}}
+
+_dict_CUaddress_mode = dict(((int(v), v) for k, v in CUaddress_mode.__members__.items()))
 {{endif}}
 {{if 'CUfilter_mode_enum' in found_types}}
 
@@ -983,6 +1021,8 @@ class CUfilter_mode(IntEnum):
 
     #: Linear filter mode
     CU_TR_FILTER_MODE_LINEAR = cydriver.CUfilter_mode_enum.CU_TR_FILTER_MODE_LINEAR{{endif}}
+
+_dict_CUfilter_mode = dict(((int(v), v) for k, v in CUfilter_mode.__members__.items()))
 {{endif}}
 {{if 'CUdevice_attribute_enum' in found_types}}
 
@@ -1625,6 +1665,8 @@ class CUdevice_attribute(IntEnum):
     CU_DEVICE_ATTRIBUTE_HOST_NUMA_MULTINODE_IPC_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_NUMA_MULTINODE_IPC_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX' in found_values}}
     CU_DEVICE_ATTRIBUTE_MAX = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX{{endif}}
+
+_dict_CUdevice_attribute = dict(((int(v), v) for k, v in CUdevice_attribute.__members__.items()))
 {{endif}}
 {{if 'CUpointer_attribute_enum' in found_types}}
 
@@ -1731,6 +1773,8 @@ class CUpointer_attribute(IntEnum):
     #: points to memory that is capable to be used for hardware accelerated
     #: decompression.
     CU_POINTER_ATTRIBUTE_IS_HW_DECOMPRESS_CAPABLE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_HW_DECOMPRESS_CAPABLE{{endif}}
+
+_dict_CUpointer_attribute = dict(((int(v), v) for k, v in CUpointer_attribute.__members__.items()))
 {{endif}}
 {{if 'CUfunction_attribute_enum' in found_types}}
 
@@ -1870,6 +1914,8 @@ class CUfunction_attribute(IntEnum):
     CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_MAX' in found_values}}
     CU_FUNC_ATTRIBUTE_MAX = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX{{endif}}
+
+_dict_CUfunction_attribute = dict(((int(v), v) for k, v in CUfunction_attribute.__members__.items()))
 {{endif}}
 {{if 'CUfunc_cache_enum' in found_types}}
 
@@ -1893,6 +1939,8 @@ class CUfunc_cache(IntEnum):
 
     #: prefer equal sized L1 cache and shared memory
     CU_FUNC_CACHE_PREFER_EQUAL = cydriver.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_EQUAL{{endif}}
+
+_dict_CUfunc_cache = dict(((int(v), v) for k, v in CUfunc_cache.__members__.items()))
 {{endif}}
 {{if 'CUsharedconfig_enum' in found_types}}
 
@@ -1912,6 +1960,8 @@ class CUsharedconfig(IntEnum):
 
     #: set shared memory bank width to eight bytes
     CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = cydriver.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE{{endif}}
+
+_dict_CUsharedconfig = dict(((int(v), v) for k, v in CUsharedconfig.__members__.items()))
 {{endif}}
 {{if 'CUshared_carveout_enum' in found_types}}
 
@@ -1932,6 +1982,8 @@ class CUshared_carveout(IntEnum):
 
     #: Prefer maximum available shared memory, minimum L1 cache
     CU_SHAREDMEM_CARVEOUT_MAX_SHARED = cydriver.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_MAX_SHARED{{endif}}
+
+_dict_CUshared_carveout = dict(((int(v), v) for k, v in CUshared_carveout.__members__.items()))
 {{endif}}
 {{if 'CUmemorytype_enum' in found_types}}
 
@@ -1955,6 +2007,8 @@ class CUmemorytype(IntEnum):
 
     #: Unified device or host memory
     CU_MEMORYTYPE_UNIFIED = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED{{endif}}
+
+_dict_CUmemorytype = dict(((int(v), v) for k, v in CUmemorytype.__members__.items()))
 {{endif}}
 {{if 'CUcomputemode_enum' in found_types}}
 
@@ -1976,6 +2030,8 @@ class CUcomputemode(IntEnum):
     #: Compute-exclusive-process mode (Only one context used by a single
     #: process can be present on this device at a time)
     CU_COMPUTEMODE_EXCLUSIVE_PROCESS = cydriver.CUcomputemode_enum.CU_COMPUTEMODE_EXCLUSIVE_PROCESS{{endif}}
+
+_dict_CUcomputemode = dict(((int(v), v) for k, v in CUcomputemode.__members__.items()))
 {{endif}}
 {{if 'CUmem_advise_enum' in found_types}}
 
@@ -2009,6 +2065,8 @@ class CUmem_advise(IntEnum):
     #: Let the Unified Memory subsystem decide on the page faulting policy
     #: for the specified device
     CU_MEM_ADVISE_UNSET_ACCESSED_BY = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_ACCESSED_BY{{endif}}
+
+_dict_CUmem_advise = dict(((int(v), v) for k, v in CUmem_advise.__members__.items()))
 {{endif}}
 {{if 'CUmem_range_attribute_enum' in found_types}}
 
@@ -2050,6 +2108,8 @@ class CUmem_range_attribute(IntEnum):
 
     #: The last location id to which the range was prefetched
     CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_ID = cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_ID{{endif}}
+
+_dict_CUmem_range_attribute = dict(((int(v), v) for k, v in CUmem_range_attribute.__members__.items()))
 {{endif}}
 {{if 'CUjit_option_enum' in found_types}}
 
@@ -2316,6 +2376,8 @@ class CUjit_option(IntEnum):
     CU_JIT_OVERRIDE_DIRECTIVE_VALUES = cydriver.CUjit_option_enum.CU_JIT_OVERRIDE_DIRECTIVE_VALUES{{endif}}
     {{if 'CU_JIT_NUM_OPTIONS' in found_values}}
     CU_JIT_NUM_OPTIONS = cydriver.CUjit_option_enum.CU_JIT_NUM_OPTIONS{{endif}}
+
+_dict_CUjit_option = dict(((int(v), v) for k, v in CUjit_option.__members__.items()))
 {{endif}}
 {{if 'CUjit_target_enum' in found_types}}
 
@@ -2422,6 +2484,8 @@ class CUjit_target(IntEnum):
     CU_TARGET_COMPUTE_101A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_101A{{endif}}
     {{if 'CU_TARGET_COMPUTE_120A' in found_values}}
     CU_TARGET_COMPUTE_120A = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_120A{{endif}}
+
+_dict_CUjit_target = dict(((int(v), v) for k, v in CUjit_target.__members__.items()))
 {{endif}}
 {{if 'CUjit_fallback_enum' in found_types}}
 
@@ -2438,6 +2502,8 @@ class CUjit_fallback(IntEnum):
     #: Prefer to fall back to compatible binary code if exact match not
     #: found
     CU_PREFER_BINARY = cydriver.CUjit_fallback_enum.CU_PREFER_BINARY{{endif}}
+
+_dict_CUjit_fallback = dict(((int(v), v) for k, v in CUjit_fallback.__members__.items()))
 {{endif}}
 {{if 'CUjit_cacheMode_enum' in found_types}}
 
@@ -2457,6 +2523,8 @@ class CUjit_cacheMode(IntEnum):
 
     #: Compile with L1 cache enabled
     CU_JIT_CACHE_OPTION_CA = cydriver.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_CA{{endif}}
+
+_dict_CUjit_cacheMode = dict(((int(v), v) for k, v in CUjit_cacheMode.__members__.items()))
 {{endif}}
 {{if 'CUjitInputType_enum' in found_types}}
 
@@ -2500,6 +2568,8 @@ class CUjitInputType(IntEnum):
     CU_JIT_INPUT_NVVM = cydriver.CUjitInputType_enum.CU_JIT_INPUT_NVVM{{endif}}
     {{if 'CU_JIT_NUM_INPUT_TYPES' in found_values}}
     CU_JIT_NUM_INPUT_TYPES = cydriver.CUjitInputType_enum.CU_JIT_NUM_INPUT_TYPES{{endif}}
+
+_dict_CUjitInputType = dict(((int(v), v) for k, v in CUjitInputType.__members__.items()))
 {{endif}}
 {{if 'CUgraphicsRegisterFlags_enum' in found_types}}
 
@@ -2517,6 +2587,8 @@ class CUgraphicsRegisterFlags(IntEnum):
     CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST{{endif}}
     {{if 'CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER' in found_values}}
     CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER{{endif}}
+
+_dict_CUgraphicsRegisterFlags = dict(((int(v), v) for k, v in CUgraphicsRegisterFlags.__members__.items()))
 {{endif}}
 {{if 'CUgraphicsMapResourceFlags_enum' in found_types}}
 
@@ -2530,6 +2602,8 @@ class CUgraphicsMapResourceFlags(IntEnum):
     CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = cydriver.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY{{endif}}
     {{if 'CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD' in found_values}}
     CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = cydriver.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD{{endif}}
+
+_dict_CUgraphicsMapResourceFlags = dict(((int(v), v) for k, v in CUgraphicsMapResourceFlags.__members__.items()))
 {{endif}}
 {{if 'CUarray_cubemap_face_enum' in found_types}}
 
@@ -2561,6 +2635,8 @@ class CUarray_cubemap_face(IntEnum):
 
     #: Negative Z face of cubemap
     CU_CUBEMAP_FACE_NEGATIVE_Z = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_Z{{endif}}
+
+_dict_CUarray_cubemap_face = dict(((int(v), v) for k, v in CUarray_cubemap_face.__members__.items()))
 {{endif}}
 {{if 'CUlimit_enum' in found_types}}
 
@@ -2615,6 +2691,8 @@ class CUlimit(IntEnum):
     CU_LIMIT_CIG_SHMEM_FALLBACK_ENABLED = cydriver.CUlimit_enum.CU_LIMIT_CIG_SHMEM_FALLBACK_ENABLED{{endif}}
     {{if 'CU_LIMIT_MAX' in found_values}}
     CU_LIMIT_MAX = cydriver.CUlimit_enum.CU_LIMIT_MAX{{endif}}
+
+_dict_CUlimit = dict(((int(v), v) for k, v in CUlimit.__members__.items()))
 {{endif}}
 {{if 'CUresourcetype_enum' in found_types}}
 
@@ -2638,6 +2716,8 @@ class CUresourcetype(IntEnum):
 
     #: Pitch 2D resource
     CU_RESOURCE_TYPE_PITCH2D = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D{{endif}}
+
+_dict_CUresourcetype = dict(((int(v), v) for k, v in CUresourcetype.__members__.items()))
 {{endif}}
 {{if 'CUaccessProperty_enum' in found_types}}
 
@@ -2658,6 +2738,8 @@ class CUaccessProperty(IntEnum):
 
     #: Persisting access is more likely to persist in cache.
     CU_ACCESS_PROPERTY_PERSISTING = cydriver.CUaccessProperty_enum.CU_ACCESS_PROPERTY_PERSISTING{{endif}}
+
+_dict_CUaccessProperty = dict(((int(v), v) for k, v in CUaccessProperty.__members__.items()))
 {{endif}}
 {{if 'CUgraphConditionalNodeType_enum' in found_types}}
 
@@ -2682,6 +2764,8 @@ class CUgraphConditionalNodeType(IntEnum):
     #: the value of the condition. If the condition does not match a body
     #: index, no body is launched.
     CU_GRAPH_COND_TYPE_SWITCH = cydriver.CUgraphConditionalNodeType_enum.CU_GRAPH_COND_TYPE_SWITCH{{endif}}
+
+_dict_CUgraphConditionalNodeType = dict(((int(v), v) for k, v in CUgraphConditionalNodeType.__members__.items()))
 {{endif}}
 {{if 'CUgraphNodeType_enum' in found_types}}
 
@@ -2769,6 +2853,8 @@ class CUgraphNodeType(IntEnum):
     #:                                         call
     #: :py:obj:`~.cudaGraphSetConditional` from device code.
     CU_GRAPH_NODE_TYPE_CONDITIONAL = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_CONDITIONAL{{endif}}
+
+_dict_CUgraphNodeType = dict(((int(v), v) for k, v in CUgraphNodeType.__members__.items()))
 {{endif}}
 {{if 'CUgraphDependencyType_enum' in found_types}}
 
@@ -2789,6 +2875,8 @@ class CUgraphDependencyType(IntEnum):
     #: :py:obj:`~.CU_GRAPH_KERNEL_NODE_PORT_PROGRAMMATIC` or
     #: :py:obj:`~.CU_GRAPH_KERNEL_NODE_PORT_LAUNCH_ORDER` outgoing port.
     CU_GRAPH_DEPENDENCY_TYPE_PROGRAMMATIC = cydriver.CUgraphDependencyType_enum.CU_GRAPH_DEPENDENCY_TYPE_PROGRAMMATIC{{endif}}
+
+_dict_CUgraphDependencyType = dict(((int(v), v) for k, v in CUgraphDependencyType.__members__.items()))
 {{endif}}
 {{if 'CUgraphInstantiateResult_enum' in found_types}}
 
@@ -2824,6 +2912,8 @@ class CUgraphInstantiateResult(IntEnum):
     #: One or more conditional handles are not associated with conditional
     #: nodes
     CUDA_GRAPH_INSTANTIATE_CONDITIONAL_HANDLE_UNUSED = cydriver.CUgraphInstantiateResult_enum.CUDA_GRAPH_INSTANTIATE_CONDITIONAL_HANDLE_UNUSED{{endif}}
+
+_dict_CUgraphInstantiateResult = dict(((int(v), v) for k, v in CUgraphInstantiateResult.__members__.items()))
 {{endif}}
 {{if 'CUsynchronizationPolicy_enum' in found_types}}
 
@@ -2839,6 +2929,8 @@ class CUsynchronizationPolicy(IntEnum):
     CU_SYNC_POLICY_YIELD = cydriver.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_YIELD{{endif}}
     {{if 'CU_SYNC_POLICY_BLOCKING_SYNC' in found_values}}
     CU_SYNC_POLICY_BLOCKING_SYNC = cydriver.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_BLOCKING_SYNC{{endif}}
+
+_dict_CUsynchronizationPolicy = dict(((int(v), v) for k, v in CUsynchronizationPolicy.__members__.items()))
 {{endif}}
 {{if 'CUclusterSchedulingPolicy_enum' in found_types}}
 
@@ -2860,6 +2952,8 @@ class CUclusterSchedulingPolicy(IntEnum):
     #: allow the hardware to load-balance the blocks in a cluster to the
     #: SMs
     CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING = cydriver.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING{{endif}}
+
+_dict_CUclusterSchedulingPolicy = dict(((int(v), v) for k, v in CUclusterSchedulingPolicy.__members__.items()))
 {{endif}}
 {{if 'CUlaunchMemSyncDomain_enum' in found_types}}
 
@@ -2892,6 +2986,8 @@ class CUlaunchMemSyncDomain(IntEnum):
 
     #: Launch kernels in the remote domain
     CU_LAUNCH_MEM_SYNC_DOMAIN_REMOTE = cydriver.CUlaunchMemSyncDomain_enum.CU_LAUNCH_MEM_SYNC_DOMAIN_REMOTE{{endif}}
+
+_dict_CUlaunchMemSyncDomain = dict(((int(v), v) for k, v in CUlaunchMemSyncDomain.__members__.items()))
 {{endif}}
 {{if 'CUlaunchAttributeID_enum' in found_types}}
 
@@ -3082,6 +3178,8 @@ class CUlaunchAttributeID(IntEnum):
     #: is only a hint, and the CUDA driver can choose a different
     #: configuration if required for the launch.
     CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT{{endif}}
+
+_dict_CUlaunchAttributeID = dict(((int(v), v) for k, v in CUlaunchAttributeID.__members__.items()))
 {{endif}}
 {{if 'CUstreamCaptureStatus_enum' in found_types}}
 
@@ -3103,6 +3201,8 @@ class CUstreamCaptureStatus(IntEnum):
     #: Stream is part of a capture sequence that has been invalidated, but
     #: not terminated
     CU_STREAM_CAPTURE_STATUS_INVALIDATED = cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_INVALIDATED{{endif}}
+
+_dict_CUstreamCaptureStatus = dict(((int(v), v) for k, v in CUstreamCaptureStatus.__members__.items()))
 {{endif}}
 {{if 'CUstreamCaptureMode_enum' in found_types}}
 
@@ -3118,6 +3218,8 @@ class CUstreamCaptureMode(IntEnum):
     CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = cydriver.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_THREAD_LOCAL{{endif}}
     {{if 'CU_STREAM_CAPTURE_MODE_RELAXED' in found_values}}
     CU_STREAM_CAPTURE_MODE_RELAXED = cydriver.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_RELAXED{{endif}}
+
+_dict_CUstreamCaptureMode = dict(((int(v), v) for k, v in CUstreamCaptureMode.__members__.items()))
 {{endif}}
 {{if 'CUdriverProcAddress_flags_enum' in found_types}}
 
@@ -3138,6 +3240,8 @@ class CUdriverProcAddress_flags(IntEnum):
 
     #: Search for per-thread versions of driver symbols.
     CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM = cydriver.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM{{endif}}
+
+_dict_CUdriverProcAddress_flags = dict(((int(v), v) for k, v in CUdriverProcAddress_flags.__members__.items()))
 {{endif}}
 {{if 'CUdriverProcAddressQueryResult_enum' in found_types}}
 
@@ -3158,6 +3262,8 @@ class CUdriverProcAddressQueryResult(IntEnum):
 
     #: Symbol was found but version supplied was not sufficient
     CU_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = cydriver.CUdriverProcAddressQueryResult_enum.CU_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT{{endif}}
+
+_dict_CUdriverProcAddressQueryResult = dict(((int(v), v) for k, v in CUdriverProcAddressQueryResult.__members__.items()))
 {{endif}}
 {{if 'CUexecAffinityType_enum' in found_types}}
 
@@ -3171,6 +3277,8 @@ class CUexecAffinityType(IntEnum):
     CU_EXEC_AFFINITY_TYPE_SM_COUNT = cydriver.CUexecAffinityType_enum.CU_EXEC_AFFINITY_TYPE_SM_COUNT{{endif}}
     {{if 'CU_EXEC_AFFINITY_TYPE_MAX' in found_values}}
     CU_EXEC_AFFINITY_TYPE_MAX = cydriver.CUexecAffinityType_enum.CU_EXEC_AFFINITY_TYPE_MAX{{endif}}
+
+_dict_CUexecAffinityType = dict(((int(v), v) for k, v in CUexecAffinityType.__members__.items()))
 {{endif}}
 {{if 'CUcigDataType_enum' in found_types}}
 
@@ -3180,6 +3288,8 @@ class CUcigDataType(IntEnum):
     """
     {{if 'CIG_DATA_TYPE_D3D12_COMMAND_QUEUE' in found_values}}
     CIG_DATA_TYPE_D3D12_COMMAND_QUEUE = cydriver.CUcigDataType_enum.CIG_DATA_TYPE_D3D12_COMMAND_QUEUE{{endif}}
+
+_dict_CUcigDataType = dict(((int(v), v) for k, v in CUcigDataType.__members__.items()))
 {{endif}}
 {{if 'CUlibraryOption_enum' in found_types}}
 
@@ -3205,6 +3315,8 @@ class CUlibraryOption(IntEnum):
     CU_LIBRARY_BINARY_IS_PRESERVED = cydriver.CUlibraryOption_enum.CU_LIBRARY_BINARY_IS_PRESERVED{{endif}}
     {{if 'CU_LIBRARY_NUM_OPTIONS' in found_values}}
     CU_LIBRARY_NUM_OPTIONS = cydriver.CUlibraryOption_enum.CU_LIBRARY_NUM_OPTIONS{{endif}}
+
+_dict_CUlibraryOption = dict(((int(v), v) for k, v in CUlibraryOption.__members__.items()))
 {{endif}}
 {{if 'cudaError_enum' in found_types}}
 
@@ -3792,6 +3904,8 @@ class CUresult(IntEnum):
 
     #: This indicates that an unknown internal error has occurred.
     CUDA_ERROR_UNKNOWN = cydriver.cudaError_enum.CUDA_ERROR_UNKNOWN{{endif}}
+
+_dict_CUresult = dict(((int(v), v) for k, v in CUresult.__members__.items()))
 {{endif}}
 {{if 'CUdevice_P2PAttribute_enum' in found_types}}
 
@@ -3820,6 +3934,8 @@ class CUdevice_P2PAttribute(IntEnum):
 
     #: Accessing CUDA arrays over the link supported
     CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED = cydriver.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED{{endif}}
+
+_dict_CUdevice_P2PAttribute = dict(((int(v), v) for k, v in CUdevice_P2PAttribute.__members__.items()))
 {{endif}}
 {{if 'CUresourceViewFormat_enum' in found_types}}
 
@@ -3967,6 +4083,8 @@ class CUresourceViewFormat(IntEnum):
 
     #: Block compressed 7
     CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC7{{endif}}
+
+_dict_CUresourceViewFormat = dict(((int(v), v) for k, v in CUresourceViewFormat.__members__.items()))
 {{endif}}
 {{if 'CUtensorMapDataType_enum' in found_types}}
 
@@ -4006,6 +4124,8 @@ class CUtensorMapDataType(IntEnum):
     CU_TENSOR_MAP_DATA_TYPE_16U4_ALIGN16B = cydriver.CUtensorMapDataType_enum.CU_TENSOR_MAP_DATA_TYPE_16U4_ALIGN16B{{endif}}
     {{if 'CU_TENSOR_MAP_DATA_TYPE_16U6_ALIGN16B' in found_values}}
     CU_TENSOR_MAP_DATA_TYPE_16U6_ALIGN16B = cydriver.CUtensorMapDataType_enum.CU_TENSOR_MAP_DATA_TYPE_16U6_ALIGN16B{{endif}}
+
+_dict_CUtensorMapDataType = dict(((int(v), v) for k, v in CUtensorMapDataType.__members__.items()))
 {{endif}}
 {{if 'CUtensorMapInterleave_enum' in found_types}}
 
@@ -4019,6 +4139,8 @@ class CUtensorMapInterleave(IntEnum):
     CU_TENSOR_MAP_INTERLEAVE_16B = cydriver.CUtensorMapInterleave_enum.CU_TENSOR_MAP_INTERLEAVE_16B{{endif}}
     {{if 'CU_TENSOR_MAP_INTERLEAVE_32B' in found_values}}
     CU_TENSOR_MAP_INTERLEAVE_32B = cydriver.CUtensorMapInterleave_enum.CU_TENSOR_MAP_INTERLEAVE_32B{{endif}}
+
+_dict_CUtensorMapInterleave = dict(((int(v), v) for k, v in CUtensorMapInterleave.__members__.items()))
 {{endif}}
 {{if 'CUtensorMapSwizzle_enum' in found_types}}
 
@@ -4040,6 +4162,8 @@ class CUtensorMapSwizzle(IntEnum):
     CU_TENSOR_MAP_SWIZZLE_128B_ATOM_32B_FLIP_8B = cydriver.CUtensorMapSwizzle_enum.CU_TENSOR_MAP_SWIZZLE_128B_ATOM_32B_FLIP_8B{{endif}}
     {{if 'CU_TENSOR_MAP_SWIZZLE_128B_ATOM_64B' in found_values}}
     CU_TENSOR_MAP_SWIZZLE_128B_ATOM_64B = cydriver.CUtensorMapSwizzle_enum.CU_TENSOR_MAP_SWIZZLE_128B_ATOM_64B{{endif}}
+
+_dict_CUtensorMapSwizzle = dict(((int(v), v) for k, v in CUtensorMapSwizzle.__members__.items()))
 {{endif}}
 {{if 'CUtensorMapL2promotion_enum' in found_types}}
 
@@ -4055,6 +4179,8 @@ class CUtensorMapL2promotion(IntEnum):
     CU_TENSOR_MAP_L2_PROMOTION_L2_128B = cydriver.CUtensorMapL2promotion_enum.CU_TENSOR_MAP_L2_PROMOTION_L2_128B{{endif}}
     {{if 'CU_TENSOR_MAP_L2_PROMOTION_L2_256B' in found_values}}
     CU_TENSOR_MAP_L2_PROMOTION_L2_256B = cydriver.CUtensorMapL2promotion_enum.CU_TENSOR_MAP_L2_PROMOTION_L2_256B{{endif}}
+
+_dict_CUtensorMapL2promotion = dict(((int(v), v) for k, v in CUtensorMapL2promotion.__members__.items()))
 {{endif}}
 {{if 'CUtensorMapFloatOOBfill_enum' in found_types}}
 
@@ -4066,6 +4192,8 @@ class CUtensorMapFloatOOBfill(IntEnum):
     CU_TENSOR_MAP_FLOAT_OOB_FILL_NONE = cydriver.CUtensorMapFloatOOBfill_enum.CU_TENSOR_MAP_FLOAT_OOB_FILL_NONE{{endif}}
     {{if 'CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA' in found_values}}
     CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA = cydriver.CUtensorMapFloatOOBfill_enum.CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA{{endif}}
+
+_dict_CUtensorMapFloatOOBfill = dict(((int(v), v) for k, v in CUtensorMapFloatOOBfill.__members__.items()))
 {{endif}}
 {{if 'CUtensorMapIm2ColWideMode_enum' in found_types}}
 
@@ -4077,6 +4205,8 @@ class CUtensorMapIm2ColWideMode(IntEnum):
     CU_TENSOR_MAP_IM2COL_WIDE_MODE_W = cydriver.CUtensorMapIm2ColWideMode_enum.CU_TENSOR_MAP_IM2COL_WIDE_MODE_W{{endif}}
     {{if 'CU_TENSOR_MAP_IM2COL_WIDE_MODE_W128' in found_values}}
     CU_TENSOR_MAP_IM2COL_WIDE_MODE_W128 = cydriver.CUtensorMapIm2ColWideMode_enum.CU_TENSOR_MAP_IM2COL_WIDE_MODE_W128{{endif}}
+
+_dict_CUtensorMapIm2ColWideMode = dict(((int(v), v) for k, v in CUtensorMapIm2ColWideMode.__members__.items()))
 {{endif}}
 {{if 'CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum' in found_types}}
 
@@ -4101,6 +4231,8 @@ class CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS(IntEnum):
     #: Read-write access, the device has full read-write access to the
     #: memory
     CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE = cydriver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE{{endif}}
+
+_dict_CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS = dict(((int(v), v) for k, v in CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS.__members__.items()))
 {{endif}}
 {{if 'CUexternalMemoryHandleType_enum' in found_types}}
 
@@ -4140,6 +4272,8 @@ class CUexternalMemoryHandleType(IntEnum):
 
     #: Handle is an NvSciBuf object
     CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF{{endif}}
+
+_dict_CUexternalMemoryHandleType = dict(((int(v), v) for k, v in CUexternalMemoryHandleType.__members__.items()))
 {{endif}}
 {{if 'CUexternalSemaphoreHandleType_enum' in found_types}}
 
@@ -4189,6 +4323,8 @@ class CUexternalSemaphoreHandleType(IntEnum):
     #: Handle is an opaque shared NT handle referencing a timeline
     #: semaphore
     CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32 = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32{{endif}}
+
+_dict_CUexternalSemaphoreHandleType = dict(((int(v), v) for k, v in CUexternalSemaphoreHandleType.__members__.items()))
 {{endif}}
 {{if 'CUmemAllocationHandleType_enum' in found_types}}
 
@@ -4219,6 +4355,8 @@ class CUmemAllocationHandleType(IntEnum):
     CU_MEM_HANDLE_TYPE_FABRIC = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_FABRIC{{endif}}
     {{if 'CU_MEM_HANDLE_TYPE_MAX' in found_values}}
     CU_MEM_HANDLE_TYPE_MAX = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_MAX{{endif}}
+
+_dict_CUmemAllocationHandleType = dict(((int(v), v) for k, v in CUmemAllocationHandleType.__members__.items()))
 {{endif}}
 {{if 'CUmemAccess_flags_enum' in found_types}}
 
@@ -4240,6 +4378,8 @@ class CUmemAccess_flags(IntEnum):
     CU_MEM_ACCESS_FLAGS_PROT_READWRITE = cydriver.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_READWRITE{{endif}}
     {{if 'CU_MEM_ACCESS_FLAGS_PROT_MAX' in found_values}}
     CU_MEM_ACCESS_FLAGS_PROT_MAX = cydriver.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_MAX{{endif}}
+
+_dict_CUmemAccess_flags = dict(((int(v), v) for k, v in CUmemAccess_flags.__members__.items()))
 {{endif}}
 {{if 'CUmemLocationType_enum' in found_types}}
 
@@ -4267,6 +4407,8 @@ class CUmemLocationType(IntEnum):
     CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT = cydriver.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT{{endif}}
     {{if 'CU_MEM_LOCATION_TYPE_MAX' in found_values}}
     CU_MEM_LOCATION_TYPE_MAX = cydriver.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_MAX{{endif}}
+
+_dict_CUmemLocationType = dict(((int(v), v) for k, v in CUmemLocationType.__members__.items()))
 {{endif}}
 {{if 'CUmemAllocationType_enum' in found_types}}
 
@@ -4283,6 +4425,8 @@ class CUmemAllocationType(IntEnum):
     CU_MEM_ALLOCATION_TYPE_PINNED = cydriver.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_PINNED{{endif}}
     {{if 'CU_MEM_ALLOCATION_TYPE_MAX' in found_values}}
     CU_MEM_ALLOCATION_TYPE_MAX = cydriver.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_MAX{{endif}}
+
+_dict_CUmemAllocationType = dict(((int(v), v) for k, v in CUmemAllocationType.__members__.items()))
 {{endif}}
 {{if 'CUmemAllocationGranularity_flags_enum' in found_types}}
 
@@ -4299,6 +4443,8 @@ class CUmemAllocationGranularity_flags(IntEnum):
 
     #: Recommended granularity for allocation for best performance
     CU_MEM_ALLOC_GRANULARITY_RECOMMENDED = cydriver.CUmemAllocationGranularity_flags_enum.CU_MEM_ALLOC_GRANULARITY_RECOMMENDED{{endif}}
+
+_dict_CUmemAllocationGranularity_flags = dict(((int(v), v) for k, v in CUmemAllocationGranularity_flags.__members__.items()))
 {{endif}}
 {{if 'CUmemRangeHandleType_enum' in found_types}}
 
@@ -4310,6 +4456,8 @@ class CUmemRangeHandleType(IntEnum):
     CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD = cydriver.CUmemRangeHandleType_enum.CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD{{endif}}
     {{if 'CU_MEM_RANGE_HANDLE_TYPE_MAX' in found_values}}
     CU_MEM_RANGE_HANDLE_TYPE_MAX = cydriver.CUmemRangeHandleType_enum.CU_MEM_RANGE_HANDLE_TYPE_MAX{{endif}}
+
+_dict_CUmemRangeHandleType = dict(((int(v), v) for k, v in CUmemRangeHandleType.__members__.items()))
 {{endif}}
 {{if 'CUmemRangeFlags_enum' in found_types}}
 
@@ -4321,6 +4469,8 @@ class CUmemRangeFlags(IntEnum):
 
     #: Indicates that DMA_BUF handle should be mapped via PCIe BAR1
     CU_MEM_RANGE_FLAG_DMA_BUF_MAPPING_TYPE_PCIE = cydriver.CUmemRangeFlags_enum.CU_MEM_RANGE_FLAG_DMA_BUF_MAPPING_TYPE_PCIE{{endif}}
+
+_dict_CUmemRangeFlags = dict(((int(v), v) for k, v in CUmemRangeFlags.__members__.items()))
 {{endif}}
 {{if 'CUarraySparseSubresourceType_enum' in found_types}}
 
@@ -4332,6 +4482,8 @@ class CUarraySparseSubresourceType(IntEnum):
     CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL = cydriver.CUarraySparseSubresourceType_enum.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL{{endif}}
     {{if 'CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL' in found_values}}
     CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL = cydriver.CUarraySparseSubresourceType_enum.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL{{endif}}
+
+_dict_CUarraySparseSubresourceType = dict(((int(v), v) for k, v in CUarraySparseSubresourceType.__members__.items()))
 {{endif}}
 {{if 'CUmemOperationType_enum' in found_types}}
 
@@ -4343,6 +4495,8 @@ class CUmemOperationType(IntEnum):
     CU_MEM_OPERATION_TYPE_MAP = cydriver.CUmemOperationType_enum.CU_MEM_OPERATION_TYPE_MAP{{endif}}
     {{if 'CU_MEM_OPERATION_TYPE_UNMAP' in found_values}}
     CU_MEM_OPERATION_TYPE_UNMAP = cydriver.CUmemOperationType_enum.CU_MEM_OPERATION_TYPE_UNMAP{{endif}}
+
+_dict_CUmemOperationType = dict(((int(v), v) for k, v in CUmemOperationType.__members__.items()))
 {{endif}}
 {{if 'CUmemHandleType_enum' in found_types}}
 
@@ -4352,6 +4506,8 @@ class CUmemHandleType(IntEnum):
     """
     {{if 'CU_MEM_HANDLE_TYPE_GENERIC' in found_values}}
     CU_MEM_HANDLE_TYPE_GENERIC = cydriver.CUmemHandleType_enum.CU_MEM_HANDLE_TYPE_GENERIC{{endif}}
+
+_dict_CUmemHandleType = dict(((int(v), v) for k, v in CUmemHandleType.__members__.items()))
 {{endif}}
 {{if 'CUmemAllocationCompType_enum' in found_types}}
 
@@ -4367,6 +4523,8 @@ class CUmemAllocationCompType(IntEnum):
 
     #: Allocating compressible memory
     CU_MEM_ALLOCATION_COMP_GENERIC = cydriver.CUmemAllocationCompType_enum.CU_MEM_ALLOCATION_COMP_GENERIC{{endif}}
+
+_dict_CUmemAllocationCompType = dict(((int(v), v) for k, v in CUmemAllocationCompType.__members__.items()))
 {{endif}}
 {{if 'CUmulticastGranularity_flags_enum' in found_types}}
 
@@ -4382,6 +4540,8 @@ class CUmulticastGranularity_flags(IntEnum):
 
     #: Recommended granularity for best performance
     CU_MULTICAST_GRANULARITY_RECOMMENDED = cydriver.CUmulticastGranularity_flags_enum.CU_MULTICAST_GRANULARITY_RECOMMENDED{{endif}}
+
+_dict_CUmulticastGranularity_flags = dict(((int(v), v) for k, v in CUmulticastGranularity_flags.__members__.items()))
 {{endif}}
 {{if 'CUgraphExecUpdateResult_enum' in found_types}}
 
@@ -4430,6 +4590,8 @@ class CUgraphExecUpdateResult(IntEnum):
     #: The update failed because the node attributes changed in a way that
     #: is not supported
     CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED{{endif}}
+
+_dict_CUgraphExecUpdateResult = dict(((int(v), v) for k, v in CUgraphExecUpdateResult.__members__.items()))
 {{endif}}
 {{if 'CUmemPool_attribute_enum' in found_types}}
 
@@ -4486,6 +4648,8 @@ class CUmemPool_attribute(IntEnum):
     #: from the pool that was in use by the application since the last time
     #: it was reset. High watermark can only be reset to zero.
     CU_MEMPOOL_ATTR_USED_MEM_HIGH = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH{{endif}}
+
+_dict_CUmemPool_attribute = dict(((int(v), v) for k, v in CUmemPool_attribute.__members__.items()))
 {{endif}}
 {{if 'CUgraphMem_attribute_enum' in found_types}}
 
@@ -4515,6 +4679,8 @@ class CUgraphMem_attribute(IntEnum):
     #: currently allocated for use by the CUDA graphs asynchronous
     #: allocator.
     CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH{{endif}}
+
+_dict_CUgraphMem_attribute = dict(((int(v), v) for k, v in CUgraphMem_attribute.__members__.items()))
 {{endif}}
 {{if 'CUflushGPUDirectRDMAWritesOptions_enum' in found_types}}
 
@@ -4534,6 +4700,8 @@ class CUflushGPUDirectRDMAWritesOptions(IntEnum):
     #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported
     #: on the device.
     CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS{{endif}}
+
+_dict_CUflushGPUDirectRDMAWritesOptions = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesOptions.__members__.items()))
 {{endif}}
 {{if 'CUGPUDirectRDMAWritesOrdering_enum' in found_types}}
 
@@ -4557,6 +4725,8 @@ class CUGPUDirectRDMAWritesOrdering(IntEnum):
     #: Any CUDA device in the system can consistently consume remote writes
     #: to this device.
     CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES{{endif}}
+
+_dict_CUGPUDirectRDMAWritesOrdering = dict(((int(v), v) for k, v in CUGPUDirectRDMAWritesOrdering.__members__.items()))
 {{endif}}
 {{if 'CUflushGPUDirectRDMAWritesScope_enum' in found_types}}
 
@@ -4573,6 +4743,8 @@ class CUflushGPUDirectRDMAWritesScope(IntEnum):
 
     #: Blocks until remote writes are visible to all CUDA device contexts.
     CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES{{endif}}
+
+_dict_CUflushGPUDirectRDMAWritesScope = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesScope.__members__.items()))
 {{endif}}
 {{if 'CUflushGPUDirectRDMAWritesTarget_enum' in found_types}}
 
@@ -4585,6 +4757,8 @@ class CUflushGPUDirectRDMAWritesTarget(IntEnum):
     #: Sets the target for :py:obj:`~.cuFlushGPUDirectRDMAWrites()` to the
     #: currently active CUDA device context.
     CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = cydriver.CUflushGPUDirectRDMAWritesTarget_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX{{endif}}
+
+_dict_CUflushGPUDirectRDMAWritesTarget = dict(((int(v), v) for k, v in CUflushGPUDirectRDMAWritesTarget.__members__.items()))
 {{endif}}
 {{if 'CUgraphDebugDot_flags_enum' in found_types}}
 
@@ -4656,6 +4830,8 @@ class CUgraphDebugDot_flags(IntEnum):
 
     #: Adds conditional node parameters to output
     CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS{{endif}}
+
+_dict_CUgraphDebugDot_flags = dict(((int(v), v) for k, v in CUgraphDebugDot_flags.__members__.items()))
 {{endif}}
 {{if 'CUuserObject_flags_enum' in found_types}}
 
@@ -4668,6 +4844,8 @@ class CUuserObject_flags(IntEnum):
     #: Indicates the destructor execution is not synchronized by any CUDA
     #: handle.
     CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = cydriver.CUuserObject_flags_enum.CU_USER_OBJECT_NO_DESTRUCTOR_SYNC{{endif}}
+
+_dict_CUuserObject_flags = dict(((int(v), v) for k, v in CUuserObject_flags.__members__.items()))
 {{endif}}
 {{if 'CUuserObjectRetain_flags_enum' in found_types}}
 
@@ -4680,6 +4858,8 @@ class CUuserObjectRetain_flags(IntEnum):
     #: Transfer references from the caller rather than creating new
     #: references.
     CU_GRAPH_USER_OBJECT_MOVE = cydriver.CUuserObjectRetain_flags_enum.CU_GRAPH_USER_OBJECT_MOVE{{endif}}
+
+_dict_CUuserObjectRetain_flags = dict(((int(v), v) for k, v in CUuserObjectRetain_flags.__members__.items()))
 {{endif}}
 {{if 'CUgraphInstantiate_flags_enum' in found_types}}
 
@@ -4709,6 +4889,8 @@ class CUgraphInstantiate_flags(IntEnum):
     #: Run the graph using the per-node priority attributes rather than the
     #: priority of the stream it is launched into.
     CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY{{endif}}
+
+_dict_CUgraphInstantiate_flags = dict(((int(v), v) for k, v in CUgraphInstantiate_flags.__members__.items()))
 {{endif}}
 {{if 'CUdeviceNumaConfig_enum' in found_types}}
 
@@ -4725,6 +4907,8 @@ class CUdeviceNumaConfig(IntEnum):
     #: The GPU is a NUMA node, CU_DEVICE_ATTRIBUTE_NUMA_ID contains its
     #: NUMA ID
     CU_DEVICE_NUMA_CONFIG_NUMA_NODE = cydriver.CUdeviceNumaConfig_enum.CU_DEVICE_NUMA_CONFIG_NUMA_NODE{{endif}}
+
+_dict_CUdeviceNumaConfig = dict(((int(v), v) for k, v in CUdeviceNumaConfig.__members__.items()))
 {{endif}}
 {{if 'CUprocessState_enum' in found_types}}
 
@@ -4750,6 +4934,8 @@ class CUprocessState(IntEnum):
     #: Application entered an uncorrectable error during the
     #: checkpoint/restore process
     CU_PROCESS_STATE_FAILED = cydriver.CUprocessState_enum.CU_PROCESS_STATE_FAILED{{endif}}
+
+_dict_CUprocessState = dict(((int(v), v) for k, v in CUprocessState.__members__.items()))
 {{endif}}
 {{if 'CUmemcpyFlags_enum' in found_types}}
 
@@ -4765,6 +4951,8 @@ class CUmemcpyFlags(IntEnum):
     #: Hint to the driver to try and overlap the copy with compute work on
     #: the SMs.
     CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE = cydriver.CUmemcpyFlags_enum.CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE{{endif}}
+
+_dict_CUmemcpyFlags = dict(((int(v), v) for k, v in CUmemcpyFlags.__members__.items()))
 {{endif}}
 {{if 'CUmemcpySrcAccessOrder_enum' in found_types}}
 
@@ -4805,6 +4993,8 @@ class CUmemcpySrcAccessOrder(IntEnum):
     CU_MEMCPY_SRC_ACCESS_ORDER_ANY = cydriver.CUmemcpySrcAccessOrder_enum.CU_MEMCPY_SRC_ACCESS_ORDER_ANY{{endif}}
     {{if 'CU_MEMCPY_SRC_ACCESS_ORDER_MAX' in found_values}}
     CU_MEMCPY_SRC_ACCESS_ORDER_MAX = cydriver.CUmemcpySrcAccessOrder_enum.CU_MEMCPY_SRC_ACCESS_ORDER_MAX{{endif}}
+
+_dict_CUmemcpySrcAccessOrder = dict(((int(v), v) for k, v in CUmemcpySrcAccessOrder.__members__.items()))
 {{endif}}
 {{if 'CUmemcpy3DOperandType_enum' in found_types}}
 
@@ -4823,6 +5013,8 @@ class CUmemcpy3DOperandType(IntEnum):
     CU_MEMCPY_OPERAND_TYPE_ARRAY = cydriver.CUmemcpy3DOperandType_enum.CU_MEMCPY_OPERAND_TYPE_ARRAY{{endif}}
     {{if 'CU_MEMCPY_OPERAND_TYPE_MAX' in found_values}}
     CU_MEMCPY_OPERAND_TYPE_MAX = cydriver.CUmemcpy3DOperandType_enum.CU_MEMCPY_OPERAND_TYPE_MAX{{endif}}
+
+_dict_CUmemcpy3DOperandType = dict(((int(v), v) for k, v in CUmemcpy3DOperandType.__members__.items()))
 {{endif}}
 {{if 'CUmoduleLoadingMode_enum' in found_types}}
 
@@ -4838,6 +5030,8 @@ class CUmoduleLoadingMode(IntEnum):
 
     #: Lazy Kernel Loading is enabled
     CU_MODULE_LAZY_LOADING = cydriver.CUmoduleLoadingMode_enum.CU_MODULE_LAZY_LOADING{{endif}}
+
+_dict_CUmoduleLoadingMode = dict(((int(v), v) for k, v in CUmoduleLoadingMode.__members__.items()))
 {{endif}}
 {{if 'CUmemDecompressAlgorithm_enum' in found_types}}
 
@@ -4857,6 +5051,8 @@ class CUmemDecompressAlgorithm(IntEnum):
 
     #: Snappy is supported.
     CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY = cydriver.CUmemDecompressAlgorithm_enum.CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY{{endif}}
+
+_dict_CUmemDecompressAlgorithm = dict(((int(v), v) for k, v in CUmemDecompressAlgorithm.__members__.items()))
 {{endif}}
 {{if 'CUfunctionLoadingState_enum' in found_types}}
 
@@ -4870,6 +5066,8 @@ class CUfunctionLoadingState(IntEnum):
     CU_FUNCTION_LOADING_STATE_LOADED = cydriver.CUfunctionLoadingState_enum.CU_FUNCTION_LOADING_STATE_LOADED{{endif}}
     {{if 'CU_FUNCTION_LOADING_STATE_MAX' in found_values}}
     CU_FUNCTION_LOADING_STATE_MAX = cydriver.CUfunctionLoadingState_enum.CU_FUNCTION_LOADING_STATE_MAX{{endif}}
+
+_dict_CUfunctionLoadingState = dict(((int(v), v) for k, v in CUfunctionLoadingState.__members__.items()))
 {{endif}}
 {{if 'CUcoredumpSettings_enum' in found_types}}
 
@@ -4893,6 +5091,8 @@ class CUcoredumpSettings(IntEnum):
     CU_COREDUMP_GENERATION_FLAGS = cydriver.CUcoredumpSettings_enum.CU_COREDUMP_GENERATION_FLAGS{{endif}}
     {{if 'CU_COREDUMP_MAX' in found_values}}
     CU_COREDUMP_MAX = cydriver.CUcoredumpSettings_enum.CU_COREDUMP_MAX{{endif}}
+
+_dict_CUcoredumpSettings = dict(((int(v), v) for k, v in CUcoredumpSettings.__members__.items()))
 {{endif}}
 {{if 'CUCoredumpGenerationFlags' in found_types}}
 
@@ -4916,6 +5116,8 @@ class CUCoredumpGenerationFlags(IntEnum):
     CU_COREDUMP_SKIP_CONSTBANK_MEMORY = cydriver.CUCoredumpGenerationFlags.CU_COREDUMP_SKIP_CONSTBANK_MEMORY{{endif}}
     {{if 'CU_COREDUMP_LIGHTWEIGHT_FLAGS' in found_values}}
     CU_COREDUMP_LIGHTWEIGHT_FLAGS = cydriver.CUCoredumpGenerationFlags.CU_COREDUMP_LIGHTWEIGHT_FLAGS{{endif}}
+
+_dict_CUCoredumpGenerationFlags = dict(((int(v), v) for k, v in CUCoredumpGenerationFlags.__members__.items()))
 {{endif}}
 {{if 'CUgreenCtxCreate_flags' in found_types}}
 
@@ -4927,6 +5129,8 @@ class CUgreenCtxCreate_flags(IntEnum):
 
     #: Required. Creates a default stream to use inside the green context
     CU_GREEN_CTX_DEFAULT_STREAM = cydriver.CUgreenCtxCreate_flags.CU_GREEN_CTX_DEFAULT_STREAM{{endif}}
+
+_dict_CUgreenCtxCreate_flags = dict(((int(v), v) for k, v in CUgreenCtxCreate_flags.__members__.items()))
 {{endif}}
 {{if 'CUdevSmResourceSplit_flags' in found_types}}
 
@@ -4938,6 +5142,8 @@ class CUdevSmResourceSplit_flags(IntEnum):
     CU_DEV_SM_RESOURCE_SPLIT_IGNORE_SM_COSCHEDULING = cydriver.CUdevSmResourceSplit_flags.CU_DEV_SM_RESOURCE_SPLIT_IGNORE_SM_COSCHEDULING{{endif}}
     {{if 'CU_DEV_SM_RESOURCE_SPLIT_MAX_POTENTIAL_CLUSTER_SIZE' in found_values}}
     CU_DEV_SM_RESOURCE_SPLIT_MAX_POTENTIAL_CLUSTER_SIZE = cydriver.CUdevSmResourceSplit_flags.CU_DEV_SM_RESOURCE_SPLIT_MAX_POTENTIAL_CLUSTER_SIZE{{endif}}
+
+_dict_CUdevSmResourceSplit_flags = dict(((int(v), v) for k, v in CUdevSmResourceSplit_flags.__members__.items()))
 {{endif}}
 {{if 'CUdevResourceType' in found_types}}
 
@@ -4951,6 +5157,8 @@ class CUdevResourceType(IntEnum):
 
     #: Streaming multiprocessors related information
     CU_DEV_RESOURCE_TYPE_SM = cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_SM{{endif}}
+
+_dict_CUdevResourceType = dict(((int(v), v) for k, v in CUdevResourceType.__members__.items()))
 {{endif}}
 {{if 'CUoutput_mode_enum' in found_types}}
 
@@ -4966,6 +5174,8 @@ class CUoutput_mode(IntEnum):
 
     #: Output mode Comma separated values format.
     CU_OUT_CSV = cydriver.CUoutput_mode_enum.CU_OUT_CSV{{endif}}
+
+_dict_CUoutput_mode = dict(((int(v), v) for k, v in CUoutput_mode.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -4981,6 +5191,8 @@ class CUeglFrameType(IntEnum):
 
     #: Frame type pointer
     CU_EGL_FRAME_TYPE_PITCH = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH{{endif}}
+
+_dict_CUeglFrameType = dict(((int(v), v) for k, v in CUeglFrameType.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -5006,6 +5218,8 @@ class CUeglResourceLocationFlags(IntEnum):
 
     #: Resource location vidmem
     CU_EGL_RESOURCE_LOCATION_VIDMEM = cydriver.CUeglResourceLocationFlags_enum.CU_EGL_RESOURCE_LOCATION_VIDMEM{{endif}}
+
+_dict_CUeglResourceLocationFlags = dict(((int(v), v) for k, v in CUeglResourceLocationFlags.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -5584,6 +5798,8 @@ class CUeglColorFormat(IntEnum):
     CU_EGL_COLOR_FORMAT_UYVY_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_2020{{endif}}
     {{if True}}
     CU_EGL_COLOR_FORMAT_MAX = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_MAX{{endif}}
+
+_dict_CUeglColorFormat = dict(((int(v), v) for k, v in CUeglColorFormat.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -5605,6 +5821,8 @@ class CUGLDeviceList(IntEnum):
     #: The CUDA devices for the GPUs to be used by the current OpenGL
     #: context in the next frame
     CU_GL_DEVICE_LIST_NEXT_FRAME = cydriver.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_NEXT_FRAME{{endif}}
+
+_dict_CUGLDeviceList = dict(((int(v), v) for k, v in CUGLDeviceList.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -5618,6 +5836,8 @@ class CUGLmap_flags(IntEnum):
     CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY = cydriver.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY{{endif}}
     {{if True}}
     CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD = cydriver.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD{{endif}}
+
+_dict_CUGLmap_flags = dict(((int(v), v) for k, v in CUGLmap_flags.__members__.items()))
 {{endif}}
 {{if 'CUdeviceptr' in found_types}}
 
@@ -5956,6 +6176,8 @@ class CUkernelNodeAttrID(IntEnum):
     #: is only a hint, and the CUDA driver can choose a different
     #: configuration if required for the launch.
     CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT{{endif}}
+
+_dict_CUlaunchAttributeID = dict(((int(v), v) for k, v in CUlaunchAttributeID.__members__.items()))
 {{endif}}
 {{if 'CUlaunchAttributeID_enum' in found_types}}
 
@@ -6146,6 +6368,8 @@ class CUstreamAttrID(IntEnum):
     #: is only a hint, and the CUDA driver can choose a different
     #: configuration if required for the launch.
     CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT{{endif}}
+
+_dict_CUlaunchAttributeID = dict(((int(v), v) for k, v in CUlaunchAttributeID.__members__.items()))
 {{endif}}
 {{if 'CUmemGenericAllocationHandle' in found_types}}
 
@@ -7476,7 +7700,9 @@ cdef class CUstreamMemOpWaitValueParams_st:
     {{if 'CUstreamBatchMemOpParams_union.waitValue.operation' in found_struct}}
     @property
     def operation(self):
-        return CUstreamBatchMemOpType(self._pvt_ptr[0].waitValue.operation)
+        if self._pvt_ptr[0].waitValue.operation not in _dict_CUstreamBatchMemOpType:
+            return None
+        return _dict_CUstreamBatchMemOpType[self._pvt_ptr[0].waitValue.operation]
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
         self._pvt_ptr[0].waitValue.operation = operation.value
@@ -7664,7 +7890,9 @@ cdef class CUstreamMemOpWriteValueParams_st:
     {{if 'CUstreamBatchMemOpParams_union.writeValue.operation' in found_struct}}
     @property
     def operation(self):
-        return CUstreamBatchMemOpType(self._pvt_ptr[0].writeValue.operation)
+        if self._pvt_ptr[0].writeValue.operation not in _dict_CUstreamBatchMemOpType:
+            return None
+        return _dict_CUstreamBatchMemOpType[self._pvt_ptr[0].writeValue.operation]
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
         self._pvt_ptr[0].writeValue.operation = operation.value
@@ -7800,7 +8028,9 @@ cdef class CUstreamMemOpFlushRemoteWritesParams_st:
     {{if 'CUstreamBatchMemOpParams_union.flushRemoteWrites.operation' in found_struct}}
     @property
     def operation(self):
-        return CUstreamBatchMemOpType(self._pvt_ptr[0].flushRemoteWrites.operation)
+        if self._pvt_ptr[0].flushRemoteWrites.operation not in _dict_CUstreamBatchMemOpType:
+            return None
+        return _dict_CUstreamBatchMemOpType[self._pvt_ptr[0].flushRemoteWrites.operation]
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
         self._pvt_ptr[0].flushRemoteWrites.operation = operation.value
@@ -7864,7 +8094,9 @@ cdef class CUstreamMemOpMemoryBarrierParams_st:
     {{if 'CUstreamBatchMemOpParams_union.memoryBarrier.operation' in found_struct}}
     @property
     def operation(self):
-        return CUstreamBatchMemOpType(self._pvt_ptr[0].memoryBarrier.operation)
+        if self._pvt_ptr[0].memoryBarrier.operation not in _dict_CUstreamBatchMemOpType:
+            return None
+        return _dict_CUstreamBatchMemOpType[self._pvt_ptr[0].memoryBarrier.operation]
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
         self._pvt_ptr[0].memoryBarrier.operation = operation.value
@@ -7984,7 +8216,9 @@ cdef class CUstreamBatchMemOpParams_union:
     {{if 'CUstreamBatchMemOpParams_union.operation' in found_struct}}
     @property
     def operation(self):
-        return CUstreamBatchMemOpType(self._pvt_ptr[0].operation)
+        if self._pvt_ptr[0].operation not in _dict_CUstreamBatchMemOpType:
+            return None
+        return _dict_CUstreamBatchMemOpType[self._pvt_ptr[0].operation]
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
         self._pvt_ptr[0].operation = operation.value
@@ -8453,7 +8687,9 @@ cdef class CUasyncNotificationInfo_st:
     {{if 'CUasyncNotificationInfo_st.type' in found_struct}}
     @property
     def type(self):
-        return CUasyncNotificationType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUasyncNotificationType:
+            return None
+        return _dict_CUasyncNotificationType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUasyncNotificationType):
         self._pvt_ptr[0].type = type.value
@@ -8800,7 +9036,9 @@ cdef class CUaccessPolicyWindow_st:
     {{if 'CUaccessPolicyWindow_st.hitProp' in found_struct}}
     @property
     def hitProp(self):
-        return CUaccessProperty(self._pvt_ptr[0].hitProp)
+        if self._pvt_ptr[0].hitProp not in _dict_CUaccessProperty:
+            return None
+        return _dict_CUaccessProperty[self._pvt_ptr[0].hitProp]
     @hitProp.setter
     def hitProp(self, hitProp not None : CUaccessProperty):
         self._pvt_ptr[0].hitProp = hitProp.value
@@ -8808,7 +9046,9 @@ cdef class CUaccessPolicyWindow_st:
     {{if 'CUaccessPolicyWindow_st.missProp' in found_struct}}
     @property
     def missProp(self):
-        return CUaccessProperty(self._pvt_ptr[0].missProp)
+        if self._pvt_ptr[0].missProp not in _dict_CUaccessProperty:
+            return None
+        return _dict_CUaccessProperty[self._pvt_ptr[0].missProp]
     @missProp.setter
     def missProp(self, missProp not None : CUaccessProperty):
         self._pvt_ptr[0].missProp = missProp.value
@@ -10238,7 +10478,9 @@ cdef class CUDA_CONDITIONAL_NODE_PARAMS:
     {{if 'CUDA_CONDITIONAL_NODE_PARAMS.type' in found_struct}}
     @property
     def type(self):
-        return CUgraphConditionalNodeType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUgraphConditionalNodeType:
+            return None
+        return _dict_CUgraphConditionalNodeType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUgraphConditionalNodeType):
         self._pvt_ptr[0].type = type.value
@@ -10536,7 +10778,9 @@ cdef class CUDA_GRAPH_INSTANTIATE_PARAMS_st:
     {{if 'CUDA_GRAPH_INSTANTIATE_PARAMS_st.result_out' in found_struct}}
     @property
     def result_out(self):
-        return CUgraphInstantiateResult(self._pvt_ptr[0].result_out)
+        if self._pvt_ptr[0].result_out not in _dict_CUgraphInstantiateResult:
+            return None
+        return _dict_CUgraphInstantiateResult[self._pvt_ptr[0].result_out]
     @result_out.setter
     def result_out(self, result_out not None : CUgraphInstantiateResult):
         self._pvt_ptr[0].result_out = result_out.value
@@ -11307,7 +11551,9 @@ cdef class CUlaunchAttributeValue_union:
     {{if 'CUlaunchAttributeValue_union.syncPolicy' in found_struct}}
     @property
     def syncPolicy(self):
-        return CUsynchronizationPolicy(self._pvt_ptr[0].syncPolicy)
+        if self._pvt_ptr[0].syncPolicy not in _dict_CUsynchronizationPolicy:
+            return None
+        return _dict_CUsynchronizationPolicy[self._pvt_ptr[0].syncPolicy]
     @syncPolicy.setter
     def syncPolicy(self, syncPolicy not None : CUsynchronizationPolicy):
         self._pvt_ptr[0].syncPolicy = syncPolicy.value
@@ -11323,7 +11569,9 @@ cdef class CUlaunchAttributeValue_union:
     {{if 'CUlaunchAttributeValue_union.clusterSchedulingPolicyPreference' in found_struct}}
     @property
     def clusterSchedulingPolicyPreference(self):
-        return CUclusterSchedulingPolicy(self._pvt_ptr[0].clusterSchedulingPolicyPreference)
+        if self._pvt_ptr[0].clusterSchedulingPolicyPreference not in _dict_CUclusterSchedulingPolicy:
+            return None
+        return _dict_CUclusterSchedulingPolicy[self._pvt_ptr[0].clusterSchedulingPolicyPreference]
     @clusterSchedulingPolicyPreference.setter
     def clusterSchedulingPolicyPreference(self, clusterSchedulingPolicyPreference not None : CUclusterSchedulingPolicy):
         self._pvt_ptr[0].clusterSchedulingPolicyPreference = clusterSchedulingPolicyPreference.value
@@ -11371,7 +11619,9 @@ cdef class CUlaunchAttributeValue_union:
     {{if 'CUlaunchAttributeValue_union.memSyncDomain' in found_struct}}
     @property
     def memSyncDomain(self):
-        return CUlaunchMemSyncDomain(self._pvt_ptr[0].memSyncDomain)
+        if self._pvt_ptr[0].memSyncDomain not in _dict_CUlaunchMemSyncDomain:
+            return None
+        return _dict_CUlaunchMemSyncDomain[self._pvt_ptr[0].memSyncDomain]
     @memSyncDomain.setter
     def memSyncDomain(self, memSyncDomain not None : CUlaunchMemSyncDomain):
         self._pvt_ptr[0].memSyncDomain = memSyncDomain.value
@@ -11458,7 +11708,9 @@ cdef class CUlaunchAttribute_st:
     {{if 'CUlaunchAttribute_st.id' in found_struct}}
     @property
     def id(self):
-        return CUlaunchAttributeID(self._pvt_ptr[0].id)
+        if self._pvt_ptr[0].id not in _dict_CUlaunchAttributeID:
+            return None
+        return _dict_CUlaunchAttributeID[self._pvt_ptr[0].id]
     @id.setter
     def id(self, id not None : CUlaunchAttributeID):
         self._pvt_ptr[0].id = id.value
@@ -11873,7 +12125,9 @@ cdef class CUexecAffinityParam_st:
     {{if 'CUexecAffinityParam_st.type' in found_struct}}
     @property
     def type(self):
-        return CUexecAffinityType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUexecAffinityType:
+            return None
+        return _dict_CUexecAffinityType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUexecAffinityType):
         self._pvt_ptr[0].type = type.value
@@ -11941,7 +12195,9 @@ cdef class CUctxCigParam_st:
     {{if 'CUctxCigParam_st.sharedDataType' in found_struct}}
     @property
     def sharedDataType(self):
-        return CUcigDataType(self._pvt_ptr[0].sharedDataType)
+        if self._pvt_ptr[0].sharedDataType not in _dict_CUcigDataType:
+            return None
+        return _dict_CUcigDataType[self._pvt_ptr[0].sharedDataType]
     @sharedDataType.setter
     def sharedDataType(self, sharedDataType not None : CUcigDataType):
         self._pvt_ptr[0].sharedDataType = sharedDataType.value
@@ -12407,7 +12663,9 @@ cdef class CUDA_MEMCPY2D_st:
     {{if 'CUDA_MEMCPY2D_st.srcMemoryType' in found_struct}}
     @property
     def srcMemoryType(self):
-        return CUmemorytype(self._pvt_ptr[0].srcMemoryType)
+        if self._pvt_ptr[0].srcMemoryType not in _dict_CUmemorytype:
+            return None
+        return _dict_CUmemorytype[self._pvt_ptr[0].srcMemoryType]
     @srcMemoryType.setter
     def srcMemoryType(self, srcMemoryType not None : CUmemorytype):
         self._pvt_ptr[0].srcMemoryType = srcMemoryType.value
@@ -12483,7 +12741,9 @@ cdef class CUDA_MEMCPY2D_st:
     {{if 'CUDA_MEMCPY2D_st.dstMemoryType' in found_struct}}
     @property
     def dstMemoryType(self):
-        return CUmemorytype(self._pvt_ptr[0].dstMemoryType)
+        if self._pvt_ptr[0].dstMemoryType not in _dict_CUmemorytype:
+            return None
+        return _dict_CUmemorytype[self._pvt_ptr[0].dstMemoryType]
     @dstMemoryType.setter
     def dstMemoryType(self, dstMemoryType not None : CUmemorytype):
         self._pvt_ptr[0].dstMemoryType = dstMemoryType.value
@@ -12886,7 +13146,9 @@ cdef class CUDA_MEMCPY3D_st:
     {{if 'CUDA_MEMCPY3D_st.srcMemoryType' in found_struct}}
     @property
     def srcMemoryType(self):
-        return CUmemorytype(self._pvt_ptr[0].srcMemoryType)
+        if self._pvt_ptr[0].srcMemoryType not in _dict_CUmemorytype:
+            return None
+        return _dict_CUmemorytype[self._pvt_ptr[0].srcMemoryType]
     @srcMemoryType.setter
     def srcMemoryType(self, srcMemoryType not None : CUmemorytype):
         self._pvt_ptr[0].srcMemoryType = srcMemoryType.value
@@ -12995,7 +13257,9 @@ cdef class CUDA_MEMCPY3D_st:
     {{if 'CUDA_MEMCPY3D_st.dstMemoryType' in found_struct}}
     @property
     def dstMemoryType(self):
-        return CUmemorytype(self._pvt_ptr[0].dstMemoryType)
+        if self._pvt_ptr[0].dstMemoryType not in _dict_CUmemorytype:
+            return None
+        return _dict_CUmemorytype[self._pvt_ptr[0].dstMemoryType]
     @dstMemoryType.setter
     def dstMemoryType(self, dstMemoryType not None : CUmemorytype):
         self._pvt_ptr[0].dstMemoryType = dstMemoryType.value
@@ -13430,7 +13694,9 @@ cdef class CUDA_MEMCPY3D_PEER_st:
     {{if 'CUDA_MEMCPY3D_PEER_st.srcMemoryType' in found_struct}}
     @property
     def srcMemoryType(self):
-        return CUmemorytype(self._pvt_ptr[0].srcMemoryType)
+        if self._pvt_ptr[0].srcMemoryType not in _dict_CUmemorytype:
+            return None
+        return _dict_CUmemorytype[self._pvt_ptr[0].srcMemoryType]
     @srcMemoryType.setter
     def srcMemoryType(self, srcMemoryType not None : CUmemorytype):
         self._pvt_ptr[0].srcMemoryType = srcMemoryType.value
@@ -13547,7 +13813,9 @@ cdef class CUDA_MEMCPY3D_PEER_st:
     {{if 'CUDA_MEMCPY3D_PEER_st.dstMemoryType' in found_struct}}
     @property
     def dstMemoryType(self):
-        return CUmemorytype(self._pvt_ptr[0].dstMemoryType)
+        if self._pvt_ptr[0].dstMemoryType not in _dict_CUmemorytype:
+            return None
+        return _dict_CUmemorytype[self._pvt_ptr[0].dstMemoryType]
     @dstMemoryType.setter
     def dstMemoryType(self, dstMemoryType not None : CUmemorytype):
         self._pvt_ptr[0].dstMemoryType = dstMemoryType.value
@@ -13863,7 +14131,9 @@ cdef class CUDA_ARRAY_DESCRIPTOR_st:
     {{if 'CUDA_ARRAY_DESCRIPTOR_st.Format' in found_struct}}
     @property
     def Format(self):
-        return CUarray_format(self._pvt_ptr[0].Format)
+        if self._pvt_ptr[0].Format not in _dict_CUarray_format:
+            return None
+        return _dict_CUarray_format[self._pvt_ptr[0].Format]
     @Format.setter
     def Format(self, Format not None : CUarray_format):
         self._pvt_ptr[0].Format = Format.value
@@ -13995,7 +14265,9 @@ cdef class CUDA_ARRAY3D_DESCRIPTOR_st:
     {{if 'CUDA_ARRAY3D_DESCRIPTOR_st.Format' in found_struct}}
     @property
     def Format(self):
-        return CUarray_format(self._pvt_ptr[0].Format)
+        if self._pvt_ptr[0].Format not in _dict_CUarray_format:
+            return None
+        return _dict_CUarray_format[self._pvt_ptr[0].Format]
     @Format.setter
     def Format(self, Format not None : CUarray_format):
         self._pvt_ptr[0].Format = Format.value
@@ -14518,7 +14790,9 @@ cdef class anon_struct9:
     {{if 'CUDA_RESOURCE_DESC_st.res.linear.format' in found_struct}}
     @property
     def format(self):
-        return CUarray_format(self._pvt_ptr[0].res.linear.format)
+        if self._pvt_ptr[0].res.linear.format not in _dict_CUarray_format:
+            return None
+        return _dict_CUarray_format[self._pvt_ptr[0].res.linear.format]
     @format.setter
     def format(self, format not None : CUarray_format):
         self._pvt_ptr[0].res.linear.format = format.value
@@ -14651,7 +14925,9 @@ cdef class anon_struct10:
     {{if 'CUDA_RESOURCE_DESC_st.res.pitch2D.format' in found_struct}}
     @property
     def format(self):
-        return CUarray_format(self._pvt_ptr[0].res.pitch2D.format)
+        if self._pvt_ptr[0].res.pitch2D.format not in _dict_CUarray_format:
+            return None
+        return _dict_CUarray_format[self._pvt_ptr[0].res.pitch2D.format]
     @format.setter
     def format(self, format not None : CUarray_format):
         self._pvt_ptr[0].res.pitch2D.format = format.value
@@ -14937,7 +15213,9 @@ cdef class CUDA_RESOURCE_DESC_st:
     {{if 'CUDA_RESOURCE_DESC_st.resType' in found_struct}}
     @property
     def resType(self):
-        return CUresourcetype(self._pvt_ptr[0].resType)
+        if self._pvt_ptr[0].resType not in _dict_CUresourcetype:
+            return None
+        return _dict_CUresourcetype[self._pvt_ptr[0].resType]
     @resType.setter
     def resType(self, resType not None : CUresourcetype):
         self._pvt_ptr[0].resType = resType.value
@@ -15093,7 +15371,7 @@ cdef class CUDA_TEXTURE_DESC_st:
     {{if 'CUDA_TEXTURE_DESC_st.addressMode' in found_struct}}
     @property
     def addressMode(self):
-        return [CUaddress_mode(_x) for _x in list(self._pvt_ptr[0].addressMode)]
+        return [_dict_CUaddress_mode[_x] if _x in _dict_CUaddress_mode else None for _x in list(self._pvt_ptr[0].addressMode)]
     @addressMode.setter
     def addressMode(self, addressMode):
         self._pvt_ptr[0].addressMode = [_x.value for _x in addressMode]
@@ -15101,7 +15379,9 @@ cdef class CUDA_TEXTURE_DESC_st:
     {{if 'CUDA_TEXTURE_DESC_st.filterMode' in found_struct}}
     @property
     def filterMode(self):
-        return CUfilter_mode(self._pvt_ptr[0].filterMode)
+        if self._pvt_ptr[0].filterMode not in _dict_CUfilter_mode:
+            return None
+        return _dict_CUfilter_mode[self._pvt_ptr[0].filterMode]
     @filterMode.setter
     def filterMode(self, filterMode not None : CUfilter_mode):
         self._pvt_ptr[0].filterMode = filterMode.value
@@ -15125,7 +15405,9 @@ cdef class CUDA_TEXTURE_DESC_st:
     {{if 'CUDA_TEXTURE_DESC_st.mipmapFilterMode' in found_struct}}
     @property
     def mipmapFilterMode(self):
-        return CUfilter_mode(self._pvt_ptr[0].mipmapFilterMode)
+        if self._pvt_ptr[0].mipmapFilterMode not in _dict_CUfilter_mode:
+            return None
+        return _dict_CUfilter_mode[self._pvt_ptr[0].mipmapFilterMode]
     @mipmapFilterMode.setter
     def mipmapFilterMode(self, mipmapFilterMode not None : CUfilter_mode):
         self._pvt_ptr[0].mipmapFilterMode = mipmapFilterMode.value
@@ -15295,7 +15577,9 @@ cdef class CUDA_RESOURCE_VIEW_DESC_st:
     {{if 'CUDA_RESOURCE_VIEW_DESC_st.format' in found_struct}}
     @property
     def format(self):
-        return CUresourceViewFormat(self._pvt_ptr[0].format)
+        if self._pvt_ptr[0].format not in _dict_CUresourceViewFormat:
+            return None
+        return _dict_CUresourceViewFormat[self._pvt_ptr[0].format]
     @format.setter
     def format(self, format not None : CUresourceViewFormat):
         self._pvt_ptr[0].format = format.value
@@ -15963,7 +16247,9 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
     {{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st.type' in found_struct}}
     @property
     def type(self):
-        return CUexternalMemoryHandleType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUexternalMemoryHandleType:
+            return None
+        return _dict_CUexternalMemoryHandleType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUexternalMemoryHandleType):
         self._pvt_ptr[0].type = type.value
@@ -16444,7 +16730,9 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
     {{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st.type' in found_struct}}
     @property
     def type(self):
-        return CUexternalSemaphoreHandleType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUexternalSemaphoreHandleType:
+            return None
+        return _dict_CUexternalSemaphoreHandleType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUexternalSemaphoreHandleType):
         self._pvt_ptr[0].type = type.value
@@ -18343,7 +18631,9 @@ cdef class CUarrayMapInfo_st:
     {{if 'CUarrayMapInfo_st.resourceType' in found_struct}}
     @property
     def resourceType(self):
-        return CUresourcetype(self._pvt_ptr[0].resourceType)
+        if self._pvt_ptr[0].resourceType not in _dict_CUresourcetype:
+            return None
+        return _dict_CUresourcetype[self._pvt_ptr[0].resourceType]
     @resourceType.setter
     def resourceType(self, resourceType not None : CUresourcetype):
         self._pvt_ptr[0].resourceType = resourceType.value
@@ -18359,7 +18649,9 @@ cdef class CUarrayMapInfo_st:
     {{if 'CUarrayMapInfo_st.subresourceType' in found_struct}}
     @property
     def subresourceType(self):
-        return CUarraySparseSubresourceType(self._pvt_ptr[0].subresourceType)
+        if self._pvt_ptr[0].subresourceType not in _dict_CUarraySparseSubresourceType:
+            return None
+        return _dict_CUarraySparseSubresourceType[self._pvt_ptr[0].subresourceType]
     @subresourceType.setter
     def subresourceType(self, subresourceType not None : CUarraySparseSubresourceType):
         self._pvt_ptr[0].subresourceType = subresourceType.value
@@ -18375,7 +18667,9 @@ cdef class CUarrayMapInfo_st:
     {{if 'CUarrayMapInfo_st.memOperationType' in found_struct}}
     @property
     def memOperationType(self):
-        return CUmemOperationType(self._pvt_ptr[0].memOperationType)
+        if self._pvt_ptr[0].memOperationType not in _dict_CUmemOperationType:
+            return None
+        return _dict_CUmemOperationType[self._pvt_ptr[0].memOperationType]
     @memOperationType.setter
     def memOperationType(self, memOperationType not None : CUmemOperationType):
         self._pvt_ptr[0].memOperationType = memOperationType.value
@@ -18383,7 +18677,9 @@ cdef class CUarrayMapInfo_st:
     {{if 'CUarrayMapInfo_st.memHandleType' in found_struct}}
     @property
     def memHandleType(self):
-        return CUmemHandleType(self._pvt_ptr[0].memHandleType)
+        if self._pvt_ptr[0].memHandleType not in _dict_CUmemHandleType:
+            return None
+        return _dict_CUmemHandleType[self._pvt_ptr[0].memHandleType]
     @memHandleType.setter
     def memHandleType(self, memHandleType not None : CUmemHandleType):
         self._pvt_ptr[0].memHandleType = memHandleType.value
@@ -18483,7 +18779,9 @@ cdef class CUmemLocation_st:
     {{if 'CUmemLocation_st.type' in found_struct}}
     @property
     def type(self):
-        return CUmemLocationType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUmemLocationType:
+            return None
+        return _dict_CUmemLocationType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUmemLocationType):
         self._pvt_ptr[0].type = type.value
@@ -18694,7 +18992,9 @@ cdef class CUmemAllocationProp_st:
     {{if 'CUmemAllocationProp_st.type' in found_struct}}
     @property
     def type(self):
-        return CUmemAllocationType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUmemAllocationType:
+            return None
+        return _dict_CUmemAllocationType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUmemAllocationType):
         self._pvt_ptr[0].type = type.value
@@ -18702,7 +19002,9 @@ cdef class CUmemAllocationProp_st:
     {{if 'CUmemAllocationProp_st.requestedHandleTypes' in found_struct}}
     @property
     def requestedHandleTypes(self):
-        return CUmemAllocationHandleType(self._pvt_ptr[0].requestedHandleTypes)
+        if self._pvt_ptr[0].requestedHandleTypes not in _dict_CUmemAllocationHandleType:
+            return None
+        return _dict_CUmemAllocationHandleType[self._pvt_ptr[0].requestedHandleTypes]
     @requestedHandleTypes.setter
     def requestedHandleTypes(self, requestedHandleTypes not None : CUmemAllocationHandleType):
         self._pvt_ptr[0].requestedHandleTypes = requestedHandleTypes.value
@@ -18905,7 +19207,9 @@ cdef class CUmemAccessDesc_st:
     {{if 'CUmemAccessDesc_st.flags' in found_struct}}
     @property
     def flags(self):
-        return CUmemAccess_flags(self._pvt_ptr[0].flags)
+        if self._pvt_ptr[0].flags not in _dict_CUmemAccess_flags:
+            return None
+        return _dict_CUmemAccess_flags[self._pvt_ptr[0].flags]
     @flags.setter
     def flags(self, flags not None : CUmemAccess_flags):
         self._pvt_ptr[0].flags = flags.value
@@ -18984,7 +19288,9 @@ cdef class CUgraphExecUpdateResultInfo_st:
     {{if 'CUgraphExecUpdateResultInfo_st.result' in found_struct}}
     @property
     def result(self):
-        return CUgraphExecUpdateResult(self._pvt_ptr[0].result)
+        if self._pvt_ptr[0].result not in _dict_CUgraphExecUpdateResult:
+            return None
+        return _dict_CUgraphExecUpdateResult[self._pvt_ptr[0].result]
     @result.setter
     def result(self, result not None : CUgraphExecUpdateResult):
         self._pvt_ptr[0].result = result.value
@@ -19137,7 +19443,9 @@ cdef class CUmemPoolProps_st:
     {{if 'CUmemPoolProps_st.allocType' in found_struct}}
     @property
     def allocType(self):
-        return CUmemAllocationType(self._pvt_ptr[0].allocType)
+        if self._pvt_ptr[0].allocType not in _dict_CUmemAllocationType:
+            return None
+        return _dict_CUmemAllocationType[self._pvt_ptr[0].allocType]
     @allocType.setter
     def allocType(self, allocType not None : CUmemAllocationType):
         self._pvt_ptr[0].allocType = allocType.value
@@ -19145,7 +19453,9 @@ cdef class CUmemPoolProps_st:
     {{if 'CUmemPoolProps_st.handleTypes' in found_struct}}
     @property
     def handleTypes(self):
-        return CUmemAllocationHandleType(self._pvt_ptr[0].handleTypes)
+        if self._pvt_ptr[0].handleTypes not in _dict_CUmemAllocationHandleType:
+            return None
+        return _dict_CUmemAllocationHandleType[self._pvt_ptr[0].handleTypes]
     @handleTypes.setter
     def handleTypes(self, handleTypes not None : CUmemAllocationHandleType):
         self._pvt_ptr[0].handleTypes = handleTypes.value
@@ -20065,7 +20375,9 @@ cdef class CUgraphNodeParams_st:
     {{if 'CUgraphNodeParams_st.type' in found_struct}}
     @property
     def type(self):
-        return CUgraphNodeType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUgraphNodeType:
+            return None
+        return _dict_CUgraphNodeType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUgraphNodeType):
         self._pvt_ptr[0].type = type.value
@@ -20524,7 +20836,9 @@ cdef class CUmemcpyAttributes_st:
     {{if 'CUmemcpyAttributes_st.srcAccessOrder' in found_struct}}
     @property
     def srcAccessOrder(self):
-        return CUmemcpySrcAccessOrder(self._pvt_ptr[0].srcAccessOrder)
+        if self._pvt_ptr[0].srcAccessOrder not in _dict_CUmemcpySrcAccessOrder:
+            return None
+        return _dict_CUmemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder]
     @srcAccessOrder.setter
     def srcAccessOrder(self, srcAccessOrder not None : CUmemcpySrcAccessOrder):
         self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value
@@ -21050,7 +21364,9 @@ cdef class CUmemcpy3DOperand_st:
     {{if 'CUmemcpy3DOperand_st.type' in found_struct}}
     @property
     def type(self):
-        return CUmemcpy3DOperandType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUmemcpy3DOperandType:
+            return None
+        return _dict_CUmemcpy3DOperandType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUmemcpy3DOperandType):
         self._pvt_ptr[0].type = type.value
@@ -21180,7 +21496,9 @@ cdef class CUDA_MEMCPY3D_BATCH_OP_st:
     {{if 'CUDA_MEMCPY3D_BATCH_OP_st.srcAccessOrder' in found_struct}}
     @property
     def srcAccessOrder(self):
-        return CUmemcpySrcAccessOrder(self._pvt_ptr[0].srcAccessOrder)
+        if self._pvt_ptr[0].srcAccessOrder not in _dict_CUmemcpySrcAccessOrder:
+            return None
+        return _dict_CUmemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder]
     @srcAccessOrder.setter
     def srcAccessOrder(self, srcAccessOrder not None : CUmemcpySrcAccessOrder):
         self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value
@@ -21347,7 +21665,9 @@ cdef class CUmemDecompressParams_st:
     {{if 'CUmemDecompressParams_st.algo' in found_struct}}
     @property
     def algo(self):
-        return CUmemDecompressAlgorithm(self._pvt_ptr[0].algo)
+        if self._pvt_ptr[0].algo not in _dict_CUmemDecompressAlgorithm:
+            return None
+        return _dict_CUmemDecompressAlgorithm[self._pvt_ptr[0].algo]
     @algo.setter
     def algo(self, algo not None : CUmemDecompressAlgorithm):
         self._pvt_ptr[0].algo = algo.value
@@ -21490,7 +21810,9 @@ cdef class CUdevResource_st:
     {{if 'CUdevResource_st.type' in found_struct}}
     @property
     def type(self):
-        return CUdevResourceType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_CUdevResourceType:
+            return None
+        return _dict_CUdevResourceType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : CUdevResourceType):
         self._pvt_ptr[0].type = type.value
@@ -21796,7 +22118,9 @@ cdef class CUeglFrame_st:
     {{if True}}
     @property
     def frameType(self):
-        return CUeglFrameType(self._pvt_ptr[0].frameType)
+        if self._pvt_ptr[0].frameType not in _dict_CUeglFrameType:
+            return None
+        return _dict_CUeglFrameType[self._pvt_ptr[0].frameType]
     @frameType.setter
     def frameType(self, frameType not None : CUeglFrameType):
         self._pvt_ptr[0].frameType = frameType.value
@@ -21804,7 +22128,9 @@ cdef class CUeglFrame_st:
     {{if True}}
     @property
     def eglColorFormat(self):
-        return CUeglColorFormat(self._pvt_ptr[0].eglColorFormat)
+        if self._pvt_ptr[0].eglColorFormat not in _dict_CUeglColorFormat:
+            return None
+        return _dict_CUeglColorFormat[self._pvt_ptr[0].eglColorFormat]
     @eglColorFormat.setter
     def eglColorFormat(self, eglColorFormat not None : CUeglColorFormat):
         self._pvt_ptr[0].eglColorFormat = eglColorFormat.value
@@ -21812,7 +22138,9 @@ cdef class CUeglFrame_st:
     {{if True}}
     @property
     def cuFormat(self):
-        return CUarray_format(self._pvt_ptr[0].cuFormat)
+        if self._pvt_ptr[0].cuFormat not in _dict_CUarray_format:
+            return None
+        return _dict_CUarray_format[self._pvt_ptr[0].cuFormat]
     @cuFormat.setter
     def cuFormat(self, cuFormat not None : CUarray_format):
         self._pvt_ptr[0].cuFormat = cuFormat.value
@@ -22248,7 +22576,7 @@ def cuGetErrorString(error not None : CUresult):
     cdef cydriver.CUresult cyerror = error.value
     cdef const char* pStr = NULL
     err = cydriver.cuGetErrorString(cyerror, &pStr)
-    return (CUresult(err), <bytes>pStr if pStr != NULL else None)
+    return (_dict_CUresult[err], <bytes>pStr if pStr != NULL else None)
 {{endif}}
 
 {{if 'cuGetErrorName' in found_functions}}
@@ -22281,7 +22609,7 @@ def cuGetErrorName(error not None : CUresult):
     cdef cydriver.CUresult cyerror = error.value
     cdef const char* pStr = NULL
     err = cydriver.cuGetErrorName(cyerror, &pStr)
-    return (CUresult(err), <bytes>pStr if pStr != NULL else None)
+    return (_dict_CUresult[err], <bytes>pStr if pStr != NULL else None)
 {{endif}}
 
 {{if 'cuInit' in found_functions}}
@@ -22301,7 +22629,7 @@ def cuInit(unsigned int Flags):
         :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_SYSTEM_DRIVER_MISMATCH`, :py:obj:`~.CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE`
     """
     err = cydriver.cuInit(Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDriverGetVersion' in found_functions}}
@@ -22330,7 +22658,7 @@ def cuDriverGetVersion():
     """
     cdef int driverVersion = 0
     err = cydriver.cuDriverGetVersion(&driverVersion)
-    return (CUresult(err), driverVersion)
+    return (_dict_CUresult[err], driverVersion)
 {{endif}}
 
 {{if 'cuDeviceGet' in found_functions}}
@@ -22360,7 +22688,7 @@ def cuDeviceGet(int ordinal):
     """
     cdef CUdevice device = CUdevice()
     err = cydriver.cuDeviceGet(<cydriver.CUdevice*>device._pvt_ptr, ordinal)
-    return (CUresult(err), device)
+    return (_dict_CUresult[err], device)
 {{endif}}
 
 {{if 'cuDeviceGetCount' in found_functions}}
@@ -22386,7 +22714,7 @@ def cuDeviceGetCount():
     """
     cdef int count = 0
     err = cydriver.cuDeviceGetCount(&count)
-    return (CUresult(err), count)
+    return (_dict_CUresult[err], count)
 {{endif}}
 
 {{if 'cuDeviceGetName' in found_functions}}
@@ -22428,7 +22756,7 @@ def cuDeviceGetName(int length, dev):
     pyname = b" " * length
     cdef char* name = pyname
     err = cydriver.cuDeviceGetName(name, length, cydev)
-    return (CUresult(err), pyname)
+    return (_dict_CUresult[err], pyname)
 {{endif}}
 
 {{if 'cuDeviceGetUuid' in found_functions}}
@@ -22470,7 +22798,7 @@ def cuDeviceGetUuid(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUuuid uuid = CUuuid()
     err = cydriver.cuDeviceGetUuid(<cydriver.CUuuid*>uuid._pvt_ptr, cydev)
-    return (CUresult(err), uuid)
+    return (_dict_CUresult[err], uuid)
 {{endif}}
 
 {{if 'cuDeviceGetUuid_v2' in found_functions}}
@@ -22509,7 +22837,7 @@ def cuDeviceGetUuid_v2(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUuuid uuid = CUuuid()
     err = cydriver.cuDeviceGetUuid_v2(<cydriver.CUuuid*>uuid._pvt_ptr, cydev)
-    return (CUresult(err), uuid)
+    return (_dict_CUresult[err], uuid)
 {{endif}}
 
 {{if 'cuDeviceGetLuid' in found_functions}}
@@ -22550,7 +22878,7 @@ def cuDeviceGetLuid(dev):
     cdef char luid[8]
     cdef unsigned int deviceNodeMask = 0
     err = cydriver.cuDeviceGetLuid(luid, &deviceNodeMask, cydev)
-    return (CUresult(err), <bytes>luid, deviceNodeMask)
+    return (_dict_CUresult[err], <bytes>luid, deviceNodeMask)
 {{endif}}
 
 {{if 'cuDeviceTotalMem_v2' in found_functions}}
@@ -22588,7 +22916,7 @@ def cuDeviceTotalMem(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef size_t numbytes = 0
     err = cydriver.cuDeviceTotalMem(&numbytes, cydev)
-    return (CUresult(err), numbytes)
+    return (_dict_CUresult[err], numbytes)
 {{endif}}
 
 {{if 'cuDeviceGetTexture1DLinearMaxWidth' in found_functions}}
@@ -22633,7 +22961,7 @@ def cuDeviceGetTexture1DLinearMaxWidth(pformat not None : CUarray_format, unsign
     cdef size_t maxWidthInElements = 0
     cdef cydriver.CUarray_format cypformat = pformat.value
     err = cydriver.cuDeviceGetTexture1DLinearMaxWidth(&maxWidthInElements, cypformat, numChannels, cydev)
-    return (CUresult(err), maxWidthInElements)
+    return (_dict_CUresult[err], maxWidthInElements)
 {{endif}}
 
 {{if 'cuDeviceGetAttribute' in found_functions}}
@@ -23067,7 +23395,7 @@ def cuDeviceGetAttribute(attrib not None : CUdevice_attribute, dev):
     cdef int pi = 0
     cdef cydriver.CUdevice_attribute cyattrib = attrib.value
     err = cydriver.cuDeviceGetAttribute(&pi, cyattrib, cydev)
-    return (CUresult(err), pi)
+    return (_dict_CUresult[err], pi)
 {{endif}}
 
 {{if 'cuDeviceGetNvSciSyncAttributes' in found_functions}}
@@ -23164,7 +23492,7 @@ def cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, dev, int flags):
     cynvSciSyncAttrList = utils.HelperInputVoidPtr(nvSciSyncAttrList)
     cdef void* cynvSciSyncAttrList_ptr = <void*><void_ptr>cynvSciSyncAttrList.cptr
     err = cydriver.cuDeviceGetNvSciSyncAttributes(cynvSciSyncAttrList_ptr, cydev, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceSetMemPool' in found_functions}}
@@ -23215,7 +23543,7 @@ def cuDeviceSetMemPool(dev, pool):
         pdev = int(CUdevice(dev))
     cydev = <cydriver.CUdevice>pdev
     err = cydriver.cuDeviceSetMemPool(cydev, cypool)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceGetMemPool' in found_functions}}
@@ -23256,7 +23584,7 @@ def cuDeviceGetMemPool(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUmemoryPool pool = CUmemoryPool()
     err = cydriver.cuDeviceGetMemPool(<cydriver.CUmemoryPool*>pool._pvt_ptr, cydev)
-    return (CUresult(err), pool)
+    return (_dict_CUresult[err], pool)
 {{endif}}
 
 {{if 'cuDeviceGetDefaultMemPool' in found_functions}}
@@ -23294,7 +23622,7 @@ def cuDeviceGetDefaultMemPool(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUmemoryPool pool_out = CUmemoryPool()
     err = cydriver.cuDeviceGetDefaultMemPool(<cydriver.CUmemoryPool*>pool_out._pvt_ptr, cydev)
-    return (CUresult(err), pool_out)
+    return (_dict_CUresult[err], pool_out)
 {{endif}}
 
 {{if 'cuDeviceGetExecAffinitySupport' in found_functions}}
@@ -23339,7 +23667,7 @@ def cuDeviceGetExecAffinitySupport(typename not None : CUexecAffinityType, dev):
     cdef int pi = 0
     cdef cydriver.CUexecAffinityType cytypename = typename.value
     err = cydriver.cuDeviceGetExecAffinitySupport(&pi, cytypename, cydev)
-    return (CUresult(err), pi)
+    return (_dict_CUresult[err], pi)
 {{endif}}
 
 {{if 'cuFlushGPUDirectRDMAWrites' in found_functions}}
@@ -23389,7 +23717,7 @@ def cuFlushGPUDirectRDMAWrites(target not None : CUflushGPUDirectRDMAWritesTarge
     cdef cydriver.CUflushGPUDirectRDMAWritesTarget cytarget = target.value
     cdef cydriver.CUflushGPUDirectRDMAWritesScope cyscope = scope.value
     err = cydriver.cuFlushGPUDirectRDMAWrites(cytarget, cyscope)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceGetProperties' in found_functions}}
@@ -23466,7 +23794,7 @@ def cuDeviceGetProperties(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUdevprop prop = CUdevprop()
     err = cydriver.cuDeviceGetProperties(<cydriver.CUdevprop*>prop._pvt_ptr, cydev)
-    return (CUresult(err), prop)
+    return (_dict_CUresult[err], prop)
 {{endif}}
 
 {{if 'cuDeviceComputeCapability' in found_functions}}
@@ -23512,7 +23840,7 @@ def cuDeviceComputeCapability(dev):
     cdef int major = 0
     cdef int minor = 0
     err = cydriver.cuDeviceComputeCapability(&major, &minor, cydev)
-    return (CUresult(err), major, minor)
+    return (_dict_CUresult[err], major, minor)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxRetain' in found_functions}}
@@ -23567,7 +23895,7 @@ def cuDevicePrimaryCtxRetain(dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUcontext pctx = CUcontext()
     err = cydriver.cuDevicePrimaryCtxRetain(<cydriver.CUcontext*>pctx._pvt_ptr, cydev)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxRelease_v2' in found_functions}}
@@ -23612,7 +23940,7 @@ def cuDevicePrimaryCtxRelease(dev):
         pdev = int(CUdevice(dev))
     cydev = <cydriver.CUdevice>pdev
     err = cydriver.cuDevicePrimaryCtxRelease(cydev)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxSetFlags_v2' in found_functions}}
@@ -23725,7 +24053,7 @@ def cuDevicePrimaryCtxSetFlags(dev, unsigned int flags):
         pdev = int(CUdevice(dev))
     cydev = <cydriver.CUdevice>pdev
     err = cydriver.cuDevicePrimaryCtxSetFlags(cydev, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxGetState' in found_functions}}
@@ -23767,7 +24095,7 @@ def cuDevicePrimaryCtxGetState(dev):
     cdef unsigned int flags = 0
     cdef int active = 0
     err = cydriver.cuDevicePrimaryCtxGetState(cydev, &flags, &active)
-    return (CUresult(err), flags, active)
+    return (_dict_CUresult[err], flags, active)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxReset_v2' in found_functions}}
@@ -23811,7 +24139,7 @@ def cuDevicePrimaryCtxReset(dev):
         pdev = int(CUdevice(dev))
     cydev = <cydriver.CUdevice>pdev
     err = cydriver.cuDevicePrimaryCtxReset(cydev)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxCreate_v2' in found_functions}}
@@ -23953,7 +24281,7 @@ def cuCtxCreate(unsigned int flags, dev):
     cydev = <cydriver.CUdevice>pdev
     cdef CUcontext pctx = CUcontext()
     err = cydriver.cuCtxCreate(<cydriver.CUcontext*>pctx._pvt_ptr, flags, cydev)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuCtxCreate_v3' in found_functions}}
@@ -24117,7 +24445,7 @@ def cuCtxCreate_v3(paramsArray : Optional[Tuple[CUexecAffinityParam] | List[CUex
     err = cydriver.cuCtxCreate_v3(<cydriver.CUcontext*>pctx._pvt_ptr, (<CUexecAffinityParam>paramsArray[0])._pvt_ptr if len(paramsArray) == 1 else cyparamsArray, numParams, flags, cydev)
     if cyparamsArray is not NULL:
         free(cyparamsArray)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuCtxCreate_v4' in found_functions}}
@@ -24293,7 +24621,7 @@ def cuCtxCreate_v4(ctxCreateParams : Optional[CUctxCreateParams], unsigned int f
     cdef CUcontext pctx = CUcontext()
     cdef cydriver.CUctxCreateParams* cyctxCreateParams_ptr = ctxCreateParams._pvt_ptr if ctxCreateParams != None else NULL
     err = cydriver.cuCtxCreate_v4(<cydriver.CUcontext*>pctx._pvt_ptr, cyctxCreateParams_ptr, flags, cydev)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuCtxDestroy_v2' in found_functions}}
@@ -24355,7 +24683,7 @@ def cuCtxDestroy(ctx):
         pctx = int(CUcontext(ctx))
     cyctx = <cydriver.CUcontext><void_ptr>pctx
     err = cydriver.cuCtxDestroy(cyctx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxPushCurrent_v2' in found_functions}}
@@ -24395,7 +24723,7 @@ def cuCtxPushCurrent(ctx):
         pctx = int(CUcontext(ctx))
     cyctx = <cydriver.CUcontext><void_ptr>pctx
     err = cydriver.cuCtxPushCurrent(cyctx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxPopCurrent_v2' in found_functions}}
@@ -24425,7 +24753,7 @@ def cuCtxPopCurrent():
     """
     cdef CUcontext pctx = CUcontext()
     err = cydriver.cuCtxPopCurrent(<cydriver.CUcontext*>pctx._pvt_ptr)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuCtxSetCurrent' in found_functions}}
@@ -24467,7 +24795,7 @@ def cuCtxSetCurrent(ctx):
         pctx = int(CUcontext(ctx))
     cyctx = <cydriver.CUcontext><void_ptr>pctx
     err = cydriver.cuCtxSetCurrent(cyctx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxGetCurrent' in found_functions}}
@@ -24493,7 +24821,7 @@ def cuCtxGetCurrent():
     """
     cdef CUcontext pctx = CUcontext()
     err = cydriver.cuCtxGetCurrent(<cydriver.CUcontext*>pctx._pvt_ptr)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuCtxGetDevice' in found_functions}}
@@ -24517,7 +24845,7 @@ def cuCtxGetDevice():
     """
     cdef CUdevice device = CUdevice()
     err = cydriver.cuCtxGetDevice(<cydriver.CUdevice*>device._pvt_ptr)
-    return (CUresult(err), device)
+    return (_dict_CUresult[err], device)
 {{endif}}
 
 {{if 'cuCtxGetFlags' in found_functions}}
@@ -24542,7 +24870,7 @@ def cuCtxGetFlags():
     """
     cdef unsigned int flags = 0
     err = cydriver.cuCtxGetFlags(&flags)
-    return (CUresult(err), flags)
+    return (_dict_CUresult[err], flags)
 {{endif}}
 
 {{if 'cuCtxSetFlags' in found_functions}}
@@ -24569,7 +24897,7 @@ def cuCtxSetFlags(unsigned int flags):
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetCurrent`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxGetSharedMemConfig`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cudaGetDeviceFlags`, :py:obj:`~.cuDevicePrimaryCtxSetFlags`,
     """
     err = cydriver.cuCtxSetFlags(flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxGetId' in found_functions}}
@@ -24609,7 +24937,7 @@ def cuCtxGetId(ctx):
     cyctx = <cydriver.CUcontext><void_ptr>pctx
     cdef unsigned long long ctxId = 0
     err = cydriver.cuCtxGetId(cyctx, &ctxId)
-    return (CUresult(err), ctxId)
+    return (_dict_CUresult[err], ctxId)
 {{endif}}
 
 {{if 'cuCtxSynchronize' in found_functions}}
@@ -24636,7 +24964,7 @@ def cuCtxSynchronize():
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cudaDeviceSynchronize`
     """
     err = cydriver.cuCtxSynchronize()
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxSetLimit' in found_functions}}
@@ -24742,7 +25070,7 @@ def cuCtxSetLimit(limit not None : CUlimit, size_t value):
     """
     cdef cydriver.CUlimit cylimit = limit.value
     err = cydriver.cuCtxSetLimit(cylimit, value)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxGetLimit' in found_functions}}
@@ -24798,7 +25126,7 @@ def cuCtxGetLimit(limit not None : CUlimit):
     cdef size_t pvalue = 0
     cdef cydriver.CUlimit cylimit = limit.value
     err = cydriver.cuCtxGetLimit(&pvalue, cylimit)
-    return (CUresult(err), pvalue)
+    return (_dict_CUresult[err], pvalue)
 {{endif}}
 
 {{if 'cuCtxGetCacheConfig' in found_functions}}
@@ -24843,7 +25171,7 @@ def cuCtxGetCacheConfig():
     """
     cdef cydriver.CUfunc_cache pconfig
     err = cydriver.cuCtxGetCacheConfig(&pconfig)
-    return (CUresult(err), CUfunc_cache(pconfig))
+    return (_dict_CUresult[err], CUfunc_cache(pconfig))
 {{endif}}
 
 {{if 'cuCtxSetCacheConfig' in found_functions}}
@@ -24900,7 +25228,7 @@ def cuCtxSetCacheConfig(config not None : CUfunc_cache):
     """
     cdef cydriver.CUfunc_cache cyconfig = config.value
     err = cydriver.cuCtxSetCacheConfig(cyconfig)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxGetApiVersion' in found_functions}}
@@ -24945,7 +25273,7 @@ def cuCtxGetApiVersion(ctx):
     cyctx = <cydriver.CUcontext><void_ptr>pctx
     cdef unsigned int version = 0
     err = cydriver.cuCtxGetApiVersion(cyctx, &version)
-    return (CUresult(err), version)
+    return (_dict_CUresult[err], version)
 {{endif}}
 
 {{if 'cuCtxGetStreamPriorityRange' in found_functions}}
@@ -24988,7 +25316,7 @@ def cuCtxGetStreamPriorityRange():
     cdef int leastPriority = 0
     cdef int greatestPriority = 0
     err = cydriver.cuCtxGetStreamPriorityRange(&leastPriority, &greatestPriority)
-    return (CUresult(err), leastPriority, greatestPriority)
+    return (_dict_CUresult[err], leastPriority, greatestPriority)
 {{endif}}
 
 {{if 'cuCtxResetPersistingL2Cache' in found_functions}}
@@ -25010,7 +25338,7 @@ def cuCtxResetPersistingL2Cache():
     :py:obj:`~.CUaccessPolicyWindow`
     """
     err = cydriver.cuCtxResetPersistingL2Cache()
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxGetExecAffinity' in found_functions}}
@@ -25044,7 +25372,7 @@ def cuCtxGetExecAffinity(typename not None : CUexecAffinityType):
     cdef CUexecAffinityParam pExecAffinity = CUexecAffinityParam()
     cdef cydriver.CUexecAffinityType cytypename = typename.value
     err = cydriver.cuCtxGetExecAffinity(<cydriver.CUexecAffinityParam*>pExecAffinity._pvt_ptr, cytypename)
-    return (CUresult(err), pExecAffinity)
+    return (_dict_CUresult[err], pExecAffinity)
 {{endif}}
 
 {{if 'cuCtxRecordEvent' in found_functions}}
@@ -25103,7 +25431,7 @@ def cuCtxRecordEvent(hCtx, hEvent):
         phCtx = int(CUcontext(hCtx))
     cyhCtx = <cydriver.CUcontext><void_ptr>phCtx
     err = cydriver.cuCtxRecordEvent(cyhCtx, cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxWaitEvent' in found_functions}}
@@ -25161,7 +25489,7 @@ def cuCtxWaitEvent(hCtx, hEvent):
         phCtx = int(CUcontext(hCtx))
     cyhCtx = <cydriver.CUcontext><void_ptr>phCtx
     err = cydriver.cuCtxWaitEvent(cyhCtx, cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxAttach' in found_functions}}
@@ -25199,7 +25527,7 @@ def cuCtxAttach(unsigned int flags):
     """
     cdef CUcontext pctx = CUcontext()
     err = cydriver.cuCtxAttach(<cydriver.CUcontext*>pctx._pvt_ptr, flags)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuCtxDetach' in found_functions}}
@@ -25240,7 +25568,7 @@ def cuCtxDetach(ctx):
         pctx = int(CUcontext(ctx))
     cyctx = <cydriver.CUcontext><void_ptr>pctx
     err = cydriver.cuCtxDetach(cyctx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxGetSharedMemConfig' in found_functions}}
@@ -25280,7 +25608,7 @@ def cuCtxGetSharedMemConfig():
     """
     cdef cydriver.CUsharedconfig pConfig
     err = cydriver.cuCtxGetSharedMemConfig(&pConfig)
-    return (CUresult(err), CUsharedconfig(pConfig))
+    return (_dict_CUresult[err], CUsharedconfig(pConfig))
 {{endif}}
 
 {{if 'cuCtxSetSharedMemConfig' in found_functions}}
@@ -25334,7 +25662,7 @@ def cuCtxSetSharedMemConfig(config not None : CUsharedconfig):
     """
     cdef cydriver.CUsharedconfig cyconfig = config.value
     err = cydriver.cuCtxSetSharedMemConfig(cyconfig)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuModuleLoad' in found_functions}}
@@ -25370,7 +25698,7 @@ def cuModuleLoad(char* fname):
     """
     cdef CUmodule module = CUmodule()
     err = cydriver.cuModuleLoad(<cydriver.CUmodule*>module._pvt_ptr, fname)
-    return (CUresult(err), module)
+    return (_dict_CUresult[err], module)
 {{endif}}
 
 {{if 'cuModuleLoadData' in found_functions}}
@@ -25404,7 +25732,7 @@ def cuModuleLoadData(image):
     cyimage = utils.HelperInputVoidPtr(image)
     cdef void* cyimage_ptr = <void*><void_ptr>cyimage.cptr
     err = cydriver.cuModuleLoadData(<cydriver.CUmodule*>module._pvt_ptr, cyimage_ptr)
-    return (CUresult(err), module)
+    return (_dict_CUresult[err], module)
 {{endif}}
 
 {{if 'cuModuleLoadDataEx' in found_functions}}
@@ -25453,7 +25781,7 @@ def cuModuleLoadDataEx(image, unsigned int numOptions, options : Optional[Tuple[
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
     cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
     err = cydriver.cuModuleLoadDataEx(<cydriver.CUmodule*>module._pvt_ptr, cyimage_ptr, numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr)
-    return (CUresult(err), module)
+    return (_dict_CUresult[err], module)
 {{endif}}
 
 {{if 'cuModuleLoadFatBinary' in found_functions}}
@@ -25493,7 +25821,7 @@ def cuModuleLoadFatBinary(fatCubin):
     cyfatCubin = utils.HelperInputVoidPtr(fatCubin)
     cdef void* cyfatCubin_ptr = <void*><void_ptr>cyfatCubin.cptr
     err = cydriver.cuModuleLoadFatBinary(<cydriver.CUmodule*>module._pvt_ptr, cyfatCubin_ptr)
-    return (CUresult(err), module)
+    return (_dict_CUresult[err], module)
 {{endif}}
 
 {{if 'cuModuleUnload' in found_functions}}
@@ -25530,7 +25858,7 @@ def cuModuleUnload(hmod):
         phmod = int(CUmodule(hmod))
     cyhmod = <cydriver.CUmodule><void_ptr>phmod
     err = cydriver.cuModuleUnload(cyhmod)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuModuleGetLoadingMode' in found_functions}}
@@ -25555,7 +25883,7 @@ def cuModuleGetLoadingMode():
     """
     cdef cydriver.CUmoduleLoadingMode mode
     err = cydriver.cuModuleGetLoadingMode(&mode)
-    return (CUresult(err), CUmoduleLoadingMode(mode))
+    return (_dict_CUresult[err], CUmoduleLoadingMode(mode))
 {{endif}}
 
 {{if 'cuModuleGetFunction' in found_functions}}
@@ -25597,7 +25925,7 @@ def cuModuleGetFunction(hmod, char* name):
     cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUfunction hfunc = CUfunction()
     err = cydriver.cuModuleGetFunction(<cydriver.CUfunction*>hfunc._pvt_ptr, cyhmod, name)
-    return (CUresult(err), hfunc)
+    return (_dict_CUresult[err], hfunc)
 {{endif}}
 
 {{if 'cuModuleGetFunctionCount' in found_functions}}
@@ -25630,7 +25958,7 @@ def cuModuleGetFunctionCount(mod):
     cymod = <cydriver.CUmodule><void_ptr>pmod
     cdef unsigned int count = 0
     err = cydriver.cuModuleGetFunctionCount(&count, cymod)
-    return (CUresult(err), count)
+    return (_dict_CUresult[err], count)
 {{endif}}
 
 {{if 'cuModuleEnumerateFunctions' in found_functions}}
@@ -25686,7 +26014,7 @@ def cuModuleEnumerateFunctions(unsigned int numFunctions, mod):
         pyfunctions = [CUfunction(init_value=<void_ptr>cyfunctions[idx]) for idx in range(numFunctions)]
     if cyfunctions is not NULL:
         free(cyfunctions)
-    return (CUresult(err), pyfunctions)
+    return (_dict_CUresult[err], pyfunctions)
 {{endif}}
 
 {{if 'cuModuleGetGlobal_v2' in found_functions}}
@@ -25732,7 +26060,7 @@ def cuModuleGetGlobal(hmod, char* name):
     cdef CUdeviceptr dptr = CUdeviceptr()
     cdef size_t numbytes = 0
     err = cydriver.cuModuleGetGlobal(<cydriver.CUdeviceptr*>dptr._pvt_ptr, &numbytes, cyhmod, name)
-    return (CUresult(err), dptr, numbytes)
+    return (_dict_CUresult[err], dptr, numbytes)
 {{endif}}
 
 {{if 'cuLinkCreate_v2' in found_functions}}
@@ -25802,7 +26130,7 @@ def cuLinkCreate(unsigned int numOptions, options : Optional[Tuple[CUjit_option]
     stateOut._keepalive.append(voidStarHelperoptionValues)
     for option in pylist:
         stateOut._keepalive.append(option)
-    return (CUresult(err), stateOut)
+    return (_dict_CUresult[err], stateOut)
 {{endif}}
 
 {{if 'cuLinkAddData_v2' in found_functions}}
@@ -25874,7 +26202,7 @@ def cuLinkAddData(state, typename not None : CUjitInputType, data, size_t size,
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
     cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
     err = cydriver.cuLinkAddData(cystate, cytypename, cydata_ptr, size, name, numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLinkAddFile_v2' in found_functions}}
@@ -25942,7 +26270,7 @@ def cuLinkAddFile(state, typename not None : CUjitInputType, char* path, unsigne
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
     cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
     err = cydriver.cuLinkAddFile(cystate, cytypename, path, numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLinkComplete' in found_functions}}
@@ -25986,7 +26314,7 @@ def cuLinkComplete(state):
     cdef void_ptr cubinOut = 0
     cdef size_t sizeOut = 0
     err = cydriver.cuLinkComplete(cystate, <void**>&cubinOut, &sizeOut)
-    return (CUresult(err), cubinOut, sizeOut)
+    return (_dict_CUresult[err], cubinOut, sizeOut)
 {{endif}}
 
 {{if 'cuLinkDestroy' in found_functions}}
@@ -26018,7 +26346,7 @@ def cuLinkDestroy(state):
         pstate = int(CUlinkState(state))
     cystate = <cydriver.CUlinkState><void_ptr>pstate
     err = cydriver.cuLinkDestroy(cystate)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuModuleGetTexRef' in found_functions}}
@@ -26064,7 +26392,7 @@ def cuModuleGetTexRef(hmod, char* name):
     cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUtexref pTexRef = CUtexref()
     err = cydriver.cuModuleGetTexRef(<cydriver.CUtexref*>pTexRef._pvt_ptr, cyhmod, name)
-    return (CUresult(err), pTexRef)
+    return (_dict_CUresult[err], pTexRef)
 {{endif}}
 
 {{if 'cuModuleGetSurfRef' in found_functions}}
@@ -26108,7 +26436,7 @@ def cuModuleGetSurfRef(hmod, char* name):
     cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUsurfref pSurfRef = CUsurfref()
     err = cydriver.cuModuleGetSurfRef(<cydriver.CUsurfref*>pSurfRef._pvt_ptr, cyhmod, name)
-    return (CUresult(err), pSurfRef)
+    return (_dict_CUresult[err], pSurfRef)
 {{endif}}
 
 {{if 'cuLibraryLoadData' in found_functions}}
@@ -26201,7 +26529,7 @@ def cuLibraryLoadData(code, jitOptions : Optional[Tuple[CUjit_option] | List[CUj
     if numLibraryOptions > len(libraryOptions): raise RuntimeError("List is too small: " + str(len(libraryOptions)) + " < " + str(numLibraryOptions))
     if numLibraryOptions > len(libraryOptionValues): raise RuntimeError("List is too small: " + str(len(libraryOptionValues)) + " < " + str(numLibraryOptions))
     err = cydriver.cuLibraryLoadData(<cydriver.CUlibrary*>library._pvt_ptr, cycode_ptr, cyjitOptions.data(), <void**><void_ptr>voidStarHelperjitOptionsValues.cptr, numJitOptions, cylibraryOptions.data(), <void**><void_ptr>voidStarHelperlibraryOptionValues.cptr, numLibraryOptions)
-    return (CUresult(err), library)
+    return (_dict_CUresult[err], library)
 {{endif}}
 
 {{if 'cuLibraryLoadFromFile' in found_functions}}
@@ -26293,7 +26621,7 @@ def cuLibraryLoadFromFile(char* fileName, jitOptions : Optional[Tuple[CUjit_opti
     if numLibraryOptions > len(libraryOptions): raise RuntimeError("List is too small: " + str(len(libraryOptions)) + " < " + str(numLibraryOptions))
     if numLibraryOptions > len(libraryOptionValues): raise RuntimeError("List is too small: " + str(len(libraryOptionValues)) + " < " + str(numLibraryOptions))
     err = cydriver.cuLibraryLoadFromFile(<cydriver.CUlibrary*>library._pvt_ptr, fileName, cyjitOptions.data(), <void**><void_ptr>voidStarHelperjitOptionsValues.cptr, numJitOptions, cylibraryOptions.data(), <void**><void_ptr>voidStarHelperlibraryOptionValues.cptr, numLibraryOptions)
-    return (CUresult(err), library)
+    return (_dict_CUresult[err], library)
 {{endif}}
 
 {{if 'cuLibraryUnload' in found_functions}}
@@ -26327,7 +26655,7 @@ def cuLibraryUnload(library):
         plibrary = int(CUlibrary(library))
     cylibrary = <cydriver.CUlibrary><void_ptr>plibrary
     err = cydriver.cuLibraryUnload(cylibrary)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLibraryGetKernel' in found_functions}}
@@ -26368,7 +26696,7 @@ def cuLibraryGetKernel(library, char* name):
     cylibrary = <cydriver.CUlibrary><void_ptr>plibrary
     cdef CUkernel pKernel = CUkernel()
     err = cydriver.cuLibraryGetKernel(<cydriver.CUkernel*>pKernel._pvt_ptr, cylibrary, name)
-    return (CUresult(err), pKernel)
+    return (_dict_CUresult[err], pKernel)
 {{endif}}
 
 {{if 'cuLibraryGetKernelCount' in found_functions}}
@@ -26401,7 +26729,7 @@ def cuLibraryGetKernelCount(lib):
     cylib = <cydriver.CUlibrary><void_ptr>plib
     cdef unsigned int count = 0
     err = cydriver.cuLibraryGetKernelCount(&count, cylib)
-    return (CUresult(err), count)
+    return (_dict_CUresult[err], count)
 {{endif}}
 
 {{if 'cuLibraryEnumerateKernels' in found_functions}}
@@ -26451,7 +26779,7 @@ def cuLibraryEnumerateKernels(unsigned int numKernels, lib):
         pykernels = [CUkernel(init_value=<void_ptr>cykernels[idx]) for idx in range(numKernels)]
     if cykernels is not NULL:
         free(cykernels)
-    return (CUresult(err), pykernels)
+    return (_dict_CUresult[err], pykernels)
 {{endif}}
 
 {{if 'cuLibraryGetModule' in found_functions}}
@@ -26490,7 +26818,7 @@ def cuLibraryGetModule(library):
     cylibrary = <cydriver.CUlibrary><void_ptr>plibrary
     cdef CUmodule pMod = CUmodule()
     err = cydriver.cuLibraryGetModule(<cydriver.CUmodule*>pMod._pvt_ptr, cylibrary)
-    return (CUresult(err), pMod)
+    return (_dict_CUresult[err], pMod)
 {{endif}}
 
 {{if 'cuKernelGetFunction' in found_functions}}
@@ -26529,7 +26857,7 @@ def cuKernelGetFunction(kernel):
     cykernel = <cydriver.CUkernel><void_ptr>pkernel
     cdef CUfunction pFunc = CUfunction()
     err = cydriver.cuKernelGetFunction(<cydriver.CUfunction*>pFunc._pvt_ptr, cykernel)
-    return (CUresult(err), pFunc)
+    return (_dict_CUresult[err], pFunc)
 {{endif}}
 
 {{if 'cuKernelGetLibrary' in found_functions}}
@@ -26567,7 +26895,7 @@ def cuKernelGetLibrary(kernel):
     cykernel = <cydriver.CUkernel><void_ptr>pkernel
     cdef CUlibrary pLib = CUlibrary()
     err = cydriver.cuKernelGetLibrary(<cydriver.CUlibrary*>pLib._pvt_ptr, cykernel)
-    return (CUresult(err), pLib)
+    return (_dict_CUresult[err], pLib)
 {{endif}}
 
 {{if 'cuLibraryGetGlobal' in found_functions}}
@@ -26613,7 +26941,7 @@ def cuLibraryGetGlobal(library, char* name):
     cdef CUdeviceptr dptr = CUdeviceptr()
     cdef size_t numbytes = 0
     err = cydriver.cuLibraryGetGlobal(<cydriver.CUdeviceptr*>dptr._pvt_ptr, &numbytes, cylibrary, name)
-    return (CUresult(err), dptr, numbytes)
+    return (_dict_CUresult[err], dptr, numbytes)
 {{endif}}
 
 {{if 'cuLibraryGetManaged' in found_functions}}
@@ -26661,7 +26989,7 @@ def cuLibraryGetManaged(library, char* name):
     cdef CUdeviceptr dptr = CUdeviceptr()
     cdef size_t numbytes = 0
     err = cydriver.cuLibraryGetManaged(<cydriver.CUdeviceptr*>dptr._pvt_ptr, &numbytes, cylibrary, name)
-    return (CUresult(err), dptr, numbytes)
+    return (_dict_CUresult[err], dptr, numbytes)
 {{endif}}
 
 {{if 'cuLibraryGetUnifiedFunction' in found_functions}}
@@ -26705,7 +27033,7 @@ def cuLibraryGetUnifiedFunction(library, char* symbol):
     cylibrary = <cydriver.CUlibrary><void_ptr>plibrary
     cdef void_ptr fptr = 0
     err = cydriver.cuLibraryGetUnifiedFunction(<void**>&fptr, cylibrary, symbol)
-    return (CUresult(err), fptr)
+    return (_dict_CUresult[err], fptr)
 {{endif}}
 
 {{if 'cuKernelGetAttribute' in found_functions}}
@@ -26837,7 +27165,7 @@ def cuKernelGetAttribute(attrib not None : CUfunction_attribute, kernel, dev):
     cdef int pi = 0
     cdef cydriver.CUfunction_attribute cyattrib = attrib.value
     err = cydriver.cuKernelGetAttribute(&pi, cyattrib, cykernel, cydev)
-    return (CUresult(err), pi)
+    return (_dict_CUresult[err], pi)
 {{endif}}
 
 {{if 'cuKernelSetAttribute' in found_functions}}
@@ -26951,7 +27279,7 @@ def cuKernelSetAttribute(attrib not None : CUfunction_attribute, int val, kernel
     cykernel = <cydriver.CUkernel><void_ptr>pkernel
     cdef cydriver.CUfunction_attribute cyattrib = attrib.value
     err = cydriver.cuKernelSetAttribute(cyattrib, val, cykernel, cydev)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuKernelSetCacheConfig' in found_functions}}
@@ -27034,7 +27362,7 @@ def cuKernelSetCacheConfig(kernel, config not None : CUfunc_cache, dev):
     cykernel = <cydriver.CUkernel><void_ptr>pkernel
     cdef cydriver.CUfunc_cache cyconfig = config.value
     err = cydriver.cuKernelSetCacheConfig(cykernel, cyconfig, cydev)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuKernelGetName' in found_functions}}
@@ -27073,7 +27401,7 @@ def cuKernelGetName(hfunc):
     cyhfunc = <cydriver.CUkernel><void_ptr>phfunc
     cdef const char* name = NULL
     err = cydriver.cuKernelGetName(&name, cyhfunc)
-    return (CUresult(err), <bytes>name if name != NULL else None)
+    return (_dict_CUresult[err], <bytes>name if name != NULL else None)
 {{endif}}
 
 {{if 'cuKernelGetParamInfo' in found_functions}}
@@ -27125,7 +27453,7 @@ def cuKernelGetParamInfo(kernel, size_t paramIndex):
     cdef size_t paramOffset = 0
     cdef size_t paramSize = 0
     err = cydriver.cuKernelGetParamInfo(cykernel, paramIndex, &paramOffset, &paramSize)
-    return (CUresult(err), paramOffset, paramSize)
+    return (_dict_CUresult[err], paramOffset, paramSize)
 {{endif}}
 
 {{if 'cuMemGetInfo_v2' in found_functions}}
@@ -27167,7 +27495,7 @@ def cuMemGetInfo():
     cdef size_t free = 0
     cdef size_t total = 0
     err = cydriver.cuMemGetInfo(&free, &total)
-    return (CUresult(err), free, total)
+    return (_dict_CUresult[err], free, total)
 {{endif}}
 
 {{if 'cuMemAlloc_v2' in found_functions}}
@@ -27200,7 +27528,7 @@ def cuMemAlloc(size_t bytesize):
     """
     cdef CUdeviceptr dptr = CUdeviceptr()
     err = cydriver.cuMemAlloc(<cydriver.CUdeviceptr*>dptr._pvt_ptr, bytesize)
-    return (CUresult(err), dptr)
+    return (_dict_CUresult[err], dptr)
 {{endif}}
 
 {{if 'cuMemAllocPitch_v2' in found_functions}}
@@ -27266,7 +27594,7 @@ def cuMemAllocPitch(size_t WidthInBytes, size_t Height, unsigned int ElementSize
     cdef CUdeviceptr dptr = CUdeviceptr()
     cdef size_t pPitch = 0
     err = cydriver.cuMemAllocPitch(<cydriver.CUdeviceptr*>dptr._pvt_ptr, &pPitch, WidthInBytes, Height, ElementSizeBytes)
-    return (CUresult(err), dptr, pPitch)
+    return (_dict_CUresult[err], dptr, pPitch)
 {{endif}}
 
 {{if 'cuMemFree_v2' in found_functions}}
@@ -27313,7 +27641,7 @@ def cuMemFree(dptr):
         pdptr = int(CUdeviceptr(dptr))
     cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     err = cydriver.cuMemFree(cydptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemGetAddressRange_v2' in found_functions}}
@@ -27356,7 +27684,7 @@ def cuMemGetAddressRange(dptr):
     cdef CUdeviceptr pbase = CUdeviceptr()
     cdef size_t psize = 0
     err = cydriver.cuMemGetAddressRange(<cydriver.CUdeviceptr*>pbase._pvt_ptr, &psize, cydptr)
-    return (CUresult(err), pbase, psize)
+    return (_dict_CUresult[err], pbase, psize)
 {{endif}}
 
 {{if 'cuMemAllocHost_v2' in found_functions}}
@@ -27410,7 +27738,7 @@ def cuMemAllocHost(size_t bytesize):
     """
     cdef void_ptr pp = 0
     err = cydriver.cuMemAllocHost(<void**>&pp, bytesize)
-    return (CUresult(err), pp)
+    return (_dict_CUresult[err], pp)
 {{endif}}
 
 {{if 'cuMemFreeHost' in found_functions}}
@@ -27439,7 +27767,7 @@ def cuMemFreeHost(p):
     cyp = utils.HelperInputVoidPtr(p)
     cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
     err = cydriver.cuMemFreeHost(cyp_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemHostAlloc' in found_functions}}
@@ -27529,7 +27857,7 @@ def cuMemHostAlloc(size_t bytesize, unsigned int Flags):
     """
     cdef void_ptr pp = 0
     err = cydriver.cuMemHostAlloc(<void**>&pp, bytesize, Flags)
-    return (CUresult(err), pp)
+    return (_dict_CUresult[err], pp)
 {{endif}}
 
 {{if 'cuMemHostGetDevicePointer_v2' in found_functions}}
@@ -27589,7 +27917,7 @@ def cuMemHostGetDevicePointer(p, unsigned int Flags):
     cyp = utils.HelperInputVoidPtr(p)
     cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
     err = cydriver.cuMemHostGetDevicePointer(<cydriver.CUdeviceptr*>pdptr._pvt_ptr, cyp_ptr, Flags)
-    return (CUresult(err), pdptr)
+    return (_dict_CUresult[err], pdptr)
 {{endif}}
 
 {{if 'cuMemHostGetFlags' in found_functions}}
@@ -27625,7 +27953,7 @@ def cuMemHostGetFlags(p):
     cyp = utils.HelperInputVoidPtr(p)
     cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
     err = cydriver.cuMemHostGetFlags(&pFlags, cyp_ptr)
-    return (CUresult(err), pFlags)
+    return (_dict_CUresult[err], pFlags)
 {{endif}}
 
 {{if 'cuMemAllocManaged' in found_functions}}
@@ -27759,7 +28087,7 @@ def cuMemAllocManaged(size_t bytesize, unsigned int flags):
     """
     cdef CUdeviceptr dptr = CUdeviceptr()
     err = cydriver.cuMemAllocManaged(<cydriver.CUdeviceptr*>dptr._pvt_ptr, bytesize, flags)
-    return (CUresult(err), dptr)
+    return (_dict_CUresult[err], dptr)
 {{endif}}
 
 {{if 'cuDeviceRegisterAsyncNotification' in found_functions}}
@@ -27853,7 +28181,7 @@ def cuDeviceRegisterAsyncNotification(device, callbackFunc, userData):
         free(cbData)
     else:
         m_global._allocated[int(callback)] = cbData
-    return (CUresult(err), callback)
+    return (_dict_CUresult[err], callback)
 {{endif}}
 
 {{if 'cuDeviceUnregisterAsyncNotification' in found_functions}}
@@ -27902,7 +28230,7 @@ def cuDeviceUnregisterAsyncNotification(device, callback):
     if err == cydriver.CUDA_SUCCESS:
         free(m_global._allocated[pcallback])
         m_global._allocated.erase(<void_ptr>pcallback)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceGetByPCIBusId' in found_functions}}
@@ -27934,7 +28262,7 @@ def cuDeviceGetByPCIBusId(char* pciBusId):
     """
     cdef CUdevice dev = CUdevice()
     err = cydriver.cuDeviceGetByPCIBusId(<cydriver.CUdevice*>dev._pvt_ptr, pciBusId)
-    return (CUresult(err), dev)
+    return (_dict_CUresult[err], dev)
 {{endif}}
 
 {{if 'cuDeviceGetPCIBusId' in found_functions}}
@@ -27980,7 +28308,7 @@ def cuDeviceGetPCIBusId(int length, dev):
     pypciBusId = b" " * length
     cdef char* pciBusId = pypciBusId
     err = cydriver.cuDeviceGetPCIBusId(pciBusId, length, cydev)
-    return (CUresult(err), pypciBusId)
+    return (_dict_CUresult[err], pypciBusId)
 {{endif}}
 
 {{if 'cuIpcGetEventHandle' in found_functions}}
@@ -28038,7 +28366,7 @@ def cuIpcGetEventHandle(event):
     cyevent = <cydriver.CUevent><void_ptr>pevent
     cdef CUipcEventHandle pHandle = CUipcEventHandle()
     err = cydriver.cuIpcGetEventHandle(<cydriver.CUipcEventHandle*>pHandle._pvt_ptr, cyevent)
-    return (CUresult(err), pHandle)
+    return (_dict_CUresult[err], pHandle)
 {{endif}}
 
 {{if 'cuIpcOpenEventHandle' in found_functions}}
@@ -28082,7 +28410,7 @@ def cuIpcOpenEventHandle(handle not None : CUipcEventHandle):
     """
     cdef CUevent phEvent = CUevent()
     err = cydriver.cuIpcOpenEventHandle(<cydriver.CUevent*>phEvent._pvt_ptr, handle._pvt_ptr[0])
-    return (CUresult(err), phEvent)
+    return (_dict_CUresult[err], phEvent)
 {{endif}}
 
 {{if 'cuIpcGetMemHandle' in found_functions}}
@@ -28135,7 +28463,7 @@ def cuIpcGetMemHandle(dptr):
     cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     cdef CUipcMemHandle pHandle = CUipcMemHandle()
     err = cydriver.cuIpcGetMemHandle(<cydriver.CUipcMemHandle*>pHandle._pvt_ptr, cydptr)
-    return (CUresult(err), pHandle)
+    return (_dict_CUresult[err], pHandle)
 {{endif}}
 
 {{if 'cuIpcOpenMemHandle_v2' in found_functions}}
@@ -28201,7 +28529,7 @@ def cuIpcOpenMemHandle(handle not None : CUipcMemHandle, unsigned int Flags):
     """
     cdef CUdeviceptr pdptr = CUdeviceptr()
     err = cydriver.cuIpcOpenMemHandle(<cydriver.CUdeviceptr*>pdptr._pvt_ptr, handle._pvt_ptr[0], Flags)
-    return (CUresult(err), pdptr)
+    return (_dict_CUresult[err], pdptr)
 {{endif}}
 
 {{if 'cuIpcCloseMemHandle' in found_functions}}
@@ -28249,7 +28577,7 @@ def cuIpcCloseMemHandle(dptr):
         pdptr = int(CUdeviceptr(dptr))
     cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     err = cydriver.cuIpcCloseMemHandle(cydptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemHostRegister_v2' in found_functions}}
@@ -28353,7 +28681,7 @@ def cuMemHostRegister(p, size_t bytesize, unsigned int Flags):
     cyp = utils.HelperInputVoidPtr(p)
     cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
     err = cydriver.cuMemHostRegister(cyp_ptr, bytesize, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemHostUnregister' in found_functions}}
@@ -28385,7 +28713,7 @@ def cuMemHostUnregister(p):
     cyp = utils.HelperInputVoidPtr(p)
     cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
     err = cydriver.cuMemHostUnregister(cyp_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy' in found_functions}}
@@ -28436,7 +28764,7 @@ def cuMemcpy(dst, src, size_t ByteCount):
         pdst = int(CUdeviceptr(dst))
     cydst = <cydriver.CUdeviceptr><void_ptr>pdst
     err = cydriver.cuMemcpy(cydst, cysrc, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyPeer' in found_functions}}
@@ -28506,7 +28834,7 @@ def cuMemcpyPeer(dstDevice, dstContext, srcDevice, srcContext, size_t ByteCount)
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemcpyPeer(cydstDevice, cydstContext, cysrcDevice, cysrcContext, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyHtoD_v2' in found_functions}}
@@ -28548,7 +28876,7 @@ def cuMemcpyHtoD(dstDevice, srcHost, size_t ByteCount):
     cysrcHost = utils.HelperInputVoidPtr(srcHost)
     cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
     err = cydriver.cuMemcpyHtoD(cydstDevice, cysrcHost_ptr, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyDtoH_v2' in found_functions}}
@@ -28590,7 +28918,7 @@ def cuMemcpyDtoH(dstHost, srcDevice, size_t ByteCount):
     cydstHost = utils.HelperInputVoidPtr(dstHost)
     cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
     err = cydriver.cuMemcpyDtoH(cydstHost_ptr, cysrcDevice, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyDtoD_v2' in found_functions}}
@@ -28638,7 +28966,7 @@ def cuMemcpyDtoD(dstDevice, srcDevice, size_t ByteCount):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemcpyDtoD(cydstDevice, cysrcDevice, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyDtoA_v2' in found_functions}}
@@ -28689,7 +29017,7 @@ def cuMemcpyDtoA(dstArray, size_t dstOffset, srcDevice, size_t ByteCount):
         pdstArray = int(CUarray(dstArray))
     cydstArray = <cydriver.CUarray><void_ptr>pdstArray
     err = cydriver.cuMemcpyDtoA(cydstArray, dstOffset, cysrcDevice, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyAtoD_v2' in found_functions}}
@@ -28742,7 +29070,7 @@ def cuMemcpyAtoD(dstDevice, srcArray, size_t srcOffset, size_t ByteCount):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemcpyAtoD(cydstDevice, cysrcArray, srcOffset, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyHtoA_v2' in found_functions}}
@@ -28787,7 +29115,7 @@ def cuMemcpyHtoA(dstArray, size_t dstOffset, srcHost, size_t ByteCount):
     cysrcHost = utils.HelperInputVoidPtr(srcHost)
     cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
     err = cydriver.cuMemcpyHtoA(cydstArray, dstOffset, cysrcHost_ptr, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyAtoH_v2' in found_functions}}
@@ -28832,7 +29160,7 @@ def cuMemcpyAtoH(dstHost, srcArray, size_t srcOffset, size_t ByteCount):
     cydstHost = utils.HelperInputVoidPtr(dstHost)
     cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
     err = cydriver.cuMemcpyAtoH(cydstHost_ptr, cysrcArray, srcOffset, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyAtoA_v2' in found_functions}}
@@ -28888,7 +29216,7 @@ def cuMemcpyAtoA(dstArray, size_t dstOffset, srcArray, size_t srcOffset, size_t
         pdstArray = int(CUarray(dstArray))
     cydstArray = <cydriver.CUarray><void_ptr>pdstArray
     err = cydriver.cuMemcpyAtoA(cydstArray, dstOffset, cysrcArray, srcOffset, ByteCount)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy2D_v2' in found_functions}}
@@ -29014,7 +29342,7 @@ def cuMemcpy2D(pCopy : Optional[CUDA_MEMCPY2D]):
     """
     cdef cydriver.CUDA_MEMCPY2D* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy2D(cypCopy_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy2DUnaligned_v2' in found_functions}}
@@ -29140,7 +29468,7 @@ def cuMemcpy2DUnaligned(pCopy : Optional[CUDA_MEMCPY2D]):
     """
     cdef cydriver.CUDA_MEMCPY2D* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy2DUnaligned(cypCopy_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy3D_v2' in found_functions}}
@@ -29269,7 +29597,7 @@ def cuMemcpy3D(pCopy : Optional[CUDA_MEMCPY3D]):
     """
     cdef cydriver.CUDA_MEMCPY3D* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy3D(cypCopy_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy3DPeer' in found_functions}}
@@ -29298,7 +29626,7 @@ def cuMemcpy3DPeer(pCopy : Optional[CUDA_MEMCPY3D_PEER]):
     """
     cdef cydriver.CUDA_MEMCPY3D_PEER* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy3DPeer(cypCopy_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyAsync' in found_functions}}
@@ -29359,7 +29687,7 @@ def cuMemcpyAsync(dst, src, size_t ByteCount, hStream):
         pdst = int(CUdeviceptr(dst))
     cydst = <cydriver.CUdeviceptr><void_ptr>pdst
     err = cydriver.cuMemcpyAsync(cydst, cysrc, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyPeerAsync' in found_functions}}
@@ -29439,7 +29767,7 @@ def cuMemcpyPeerAsync(dstDevice, dstContext, srcDevice, srcContext, size_t ByteC
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemcpyPeerAsync(cydstDevice, cydstContext, cysrcDevice, cysrcContext, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyHtoDAsync_v2' in found_functions}}
@@ -29491,7 +29819,7 @@ def cuMemcpyHtoDAsync(dstDevice, srcHost, size_t ByteCount, hStream):
     cysrcHost = utils.HelperInputVoidPtr(srcHost)
     cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
     err = cydriver.cuMemcpyHtoDAsync(cydstDevice, cysrcHost_ptr, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyDtoHAsync_v2' in found_functions}}
@@ -29543,7 +29871,7 @@ def cuMemcpyDtoHAsync(dstHost, srcDevice, size_t ByteCount, hStream):
     cydstHost = utils.HelperInputVoidPtr(dstHost)
     cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
     err = cydriver.cuMemcpyDtoHAsync(cydstHost_ptr, cysrcDevice, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyDtoDAsync_v2' in found_functions}}
@@ -29601,7 +29929,7 @@ def cuMemcpyDtoDAsync(dstDevice, srcDevice, size_t ByteCount, hStream):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemcpyDtoDAsync(cydstDevice, cysrcDevice, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyHtoAAsync_v2' in found_functions}}
@@ -29656,7 +29984,7 @@ def cuMemcpyHtoAAsync(dstArray, size_t dstOffset, srcHost, size_t ByteCount, hSt
     cysrcHost = utils.HelperInputVoidPtr(srcHost)
     cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
     err = cydriver.cuMemcpyHtoAAsync(cydstArray, dstOffset, cysrcHost_ptr, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyAtoHAsync_v2' in found_functions}}
@@ -29711,7 +30039,7 @@ def cuMemcpyAtoHAsync(dstHost, srcArray, size_t srcOffset, size_t ByteCount, hSt
     cydstHost = utils.HelperInputVoidPtr(dstHost)
     cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
     err = cydriver.cuMemcpyAtoHAsync(cydstHost_ptr, cysrcArray, srcOffset, ByteCount, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy2DAsync_v2' in found_functions}}
@@ -29854,7 +30182,7 @@ def cuMemcpy2DAsync(pCopy : Optional[CUDA_MEMCPY2D], hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef cydriver.CUDA_MEMCPY2D* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy2DAsync(cypCopy_ptr, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy3DAsync_v2' in found_functions}}
@@ -29993,7 +30321,7 @@ def cuMemcpy3DAsync(pCopy : Optional[CUDA_MEMCPY3D], hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef cydriver.CUDA_MEMCPY3D* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy3DAsync(cypCopy_ptr, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpy3DPeerAsync' in found_functions}}
@@ -30032,7 +30360,7 @@ def cuMemcpy3DPeerAsync(pCopy : Optional[CUDA_MEMCPY3D_PEER], hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef cydriver.CUDA_MEMCPY3D_PEER* cypCopy_ptr = pCopy._pvt_ptr if pCopy != None else NULL
     err = cydriver.cuMemcpy3DPeerAsync(cypCopy_ptr, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemcpyBatchAsync' in found_functions}}
@@ -30206,7 +30534,7 @@ def cuMemcpyBatchAsync(dsts : Optional[Tuple[CUdeviceptr] | List[CUdeviceptr]],
         free(cysrcs)
     if cyattrs is not NULL:
         free(cyattrs)
-    return (CUresult(err), failIdx)
+    return (_dict_CUresult[err], failIdx)
 {{endif}}
 
 {{if 'cuMemcpy3DBatchAsync' in found_functions}}
@@ -30343,7 +30671,7 @@ def cuMemcpy3DBatchAsync(size_t numOps, opList : Optional[Tuple[CUDA_MEMCPY3D_BA
     err = cydriver.cuMemcpy3DBatchAsync(numOps, (<CUDA_MEMCPY3D_BATCH_OP>opList[0])._pvt_ptr if len(opList) == 1 else cyopList, &failIdx, flags, cyhStream)
     if cyopList is not NULL:
         free(cyopList)
-    return (CUresult(err), failIdx)
+    return (_dict_CUresult[err], failIdx)
 {{endif}}
 
 {{if 'cuMemsetD8_v2' in found_functions}}
@@ -30381,7 +30709,7 @@ def cuMemsetD8(dstDevice, unsigned char uc, size_t N):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD8(cydstDevice, uc, N)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD16_v2' in found_functions}}
@@ -30420,7 +30748,7 @@ def cuMemsetD16(dstDevice, unsigned short us, size_t N):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD16(cydstDevice, us, N)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD32_v2' in found_functions}}
@@ -30459,7 +30787,7 @@ def cuMemsetD32(dstDevice, unsigned int ui, size_t N):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD32(cydstDevice, ui, N)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD2D8_v2' in found_functions}}
@@ -30505,7 +30833,7 @@ def cuMemsetD2D8(dstDevice, size_t dstPitch, unsigned char uc, size_t Width, siz
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD2D8(cydstDevice, dstPitch, uc, Width, Height)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD2D16_v2' in found_functions}}
@@ -30552,7 +30880,7 @@ def cuMemsetD2D16(dstDevice, size_t dstPitch, unsigned short us, size_t Width, s
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD2D16(cydstDevice, dstPitch, us, Width, Height)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD2D32_v2' in found_functions}}
@@ -30599,7 +30927,7 @@ def cuMemsetD2D32(dstDevice, size_t dstPitch, unsigned int ui, size_t Width, siz
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD2D32(cydstDevice, dstPitch, ui, Width, Height)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD8Async' in found_functions}}
@@ -30647,7 +30975,7 @@ def cuMemsetD8Async(dstDevice, unsigned char uc, size_t N, hStream):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD8Async(cydstDevice, uc, N, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD16Async' in found_functions}}
@@ -30696,7 +31024,7 @@ def cuMemsetD16Async(dstDevice, unsigned short us, size_t N, hStream):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD16Async(cydstDevice, us, N, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD32Async' in found_functions}}
@@ -30745,7 +31073,7 @@ def cuMemsetD32Async(dstDevice, unsigned int ui, size_t N, hStream):
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD32Async(cydstDevice, ui, N, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD2D8Async' in found_functions}}
@@ -30801,7 +31129,7 @@ def cuMemsetD2D8Async(dstDevice, size_t dstPitch, unsigned char uc, size_t Width
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD2D8Async(cydstDevice, dstPitch, uc, Width, Height, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD2D16Async' in found_functions}}
@@ -30858,7 +31186,7 @@ def cuMemsetD2D16Async(dstDevice, size_t dstPitch, unsigned short us, size_t Wid
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD2D16Async(cydstDevice, dstPitch, us, Width, Height, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemsetD2D32Async' in found_functions}}
@@ -30915,7 +31243,7 @@ def cuMemsetD2D32Async(dstDevice, size_t dstPitch, unsigned int ui, size_t Width
         pdstDevice = int(CUdeviceptr(dstDevice))
     cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     err = cydriver.cuMemsetD2D32Async(cydstDevice, dstPitch, ui, Width, Height, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuArrayCreate_v2' in found_functions}}
@@ -30983,7 +31311,7 @@ def cuArrayCreate(pAllocateArray : Optional[CUDA_ARRAY_DESCRIPTOR]):
     cdef CUarray pHandle = CUarray()
     cdef cydriver.CUDA_ARRAY_DESCRIPTOR* cypAllocateArray_ptr = pAllocateArray._pvt_ptr if pAllocateArray != None else NULL
     err = cydriver.cuArrayCreate(<cydriver.CUarray*>pHandle._pvt_ptr, cypAllocateArray_ptr)
-    return (CUresult(err), pHandle)
+    return (_dict_CUresult[err], pHandle)
 {{endif}}
 
 {{if 'cuArrayGetDescriptor_v2' in found_functions}}
@@ -31023,7 +31351,7 @@ def cuArrayGetDescriptor(hArray):
     cyhArray = <cydriver.CUarray><void_ptr>phArray
     cdef CUDA_ARRAY_DESCRIPTOR pArrayDescriptor = CUDA_ARRAY_DESCRIPTOR()
     err = cydriver.cuArrayGetDescriptor(<cydriver.CUDA_ARRAY_DESCRIPTOR*>pArrayDescriptor._pvt_ptr, cyhArray)
-    return (CUresult(err), pArrayDescriptor)
+    return (_dict_CUresult[err], pArrayDescriptor)
 {{endif}}
 
 {{if 'cuArrayGetSparseProperties' in found_functions}}
@@ -31076,7 +31404,7 @@ def cuArrayGetSparseProperties(array):
     cyarray = <cydriver.CUarray><void_ptr>parray
     cdef CUDA_ARRAY_SPARSE_PROPERTIES sparseProperties = CUDA_ARRAY_SPARSE_PROPERTIES()
     err = cydriver.cuArrayGetSparseProperties(<cydriver.CUDA_ARRAY_SPARSE_PROPERTIES*>sparseProperties._pvt_ptr, cyarray)
-    return (CUresult(err), sparseProperties)
+    return (_dict_CUresult[err], sparseProperties)
 {{endif}}
 
 {{if 'cuMipmappedArrayGetSparseProperties' in found_functions}}
@@ -31131,7 +31459,7 @@ def cuMipmappedArrayGetSparseProperties(mipmap):
     cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
     cdef CUDA_ARRAY_SPARSE_PROPERTIES sparseProperties = CUDA_ARRAY_SPARSE_PROPERTIES()
     err = cydriver.cuMipmappedArrayGetSparseProperties(<cydriver.CUDA_ARRAY_SPARSE_PROPERTIES*>sparseProperties._pvt_ptr, cymipmap)
-    return (CUresult(err), sparseProperties)
+    return (_dict_CUresult[err], sparseProperties)
 {{endif}}
 
 {{if 'cuArrayGetMemoryRequirements' in found_functions}}
@@ -31186,7 +31514,7 @@ def cuArrayGetMemoryRequirements(array, device):
     cyarray = <cydriver.CUarray><void_ptr>parray
     cdef CUDA_ARRAY_MEMORY_REQUIREMENTS memoryRequirements = CUDA_ARRAY_MEMORY_REQUIREMENTS()
     err = cydriver.cuArrayGetMemoryRequirements(<cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS*>memoryRequirements._pvt_ptr, cyarray, cydevice)
-    return (CUresult(err), memoryRequirements)
+    return (_dict_CUresult[err], memoryRequirements)
 {{endif}}
 
 {{if 'cuMipmappedArrayGetMemoryRequirements' in found_functions}}
@@ -31242,7 +31570,7 @@ def cuMipmappedArrayGetMemoryRequirements(mipmap, device):
     cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
     cdef CUDA_ARRAY_MEMORY_REQUIREMENTS memoryRequirements = CUDA_ARRAY_MEMORY_REQUIREMENTS()
     err = cydriver.cuMipmappedArrayGetMemoryRequirements(<cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS*>memoryRequirements._pvt_ptr, cymipmap, cydevice)
-    return (CUresult(err), memoryRequirements)
+    return (_dict_CUresult[err], memoryRequirements)
 {{endif}}
 
 {{if 'cuArrayGetPlane' in found_functions}}
@@ -31295,7 +31623,7 @@ def cuArrayGetPlane(hArray, unsigned int planeIdx):
     cyhArray = <cydriver.CUarray><void_ptr>phArray
     cdef CUarray pPlaneArray = CUarray()
     err = cydriver.cuArrayGetPlane(<cydriver.CUarray*>pPlaneArray._pvt_ptr, cyhArray, planeIdx)
-    return (CUresult(err), pPlaneArray)
+    return (_dict_CUresult[err], pPlaneArray)
 {{endif}}
 
 {{if 'cuArrayDestroy' in found_functions}}
@@ -31329,7 +31657,7 @@ def cuArrayDestroy(hArray):
         phArray = int(CUarray(hArray))
     cyhArray = <cydriver.CUarray><void_ptr>phArray
     err = cydriver.cuArrayDestroy(cyhArray)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuArray3DCreate_v2' in found_functions}}
@@ -31461,7 +31789,7 @@ def cuArray3DCreate(pAllocateArray : Optional[CUDA_ARRAY3D_DESCRIPTOR]):
     cdef CUarray pHandle = CUarray()
     cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR* cypAllocateArray_ptr = pAllocateArray._pvt_ptr if pAllocateArray != None else NULL
     err = cydriver.cuArray3DCreate(<cydriver.CUarray*>pHandle._pvt_ptr, cypAllocateArray_ptr)
-    return (CUresult(err), pHandle)
+    return (_dict_CUresult[err], pHandle)
 {{endif}}
 
 {{if 'cuArray3DGetDescriptor_v2' in found_functions}}
@@ -31505,7 +31833,7 @@ def cuArray3DGetDescriptor(hArray):
     cyhArray = <cydriver.CUarray><void_ptr>phArray
     cdef CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor = CUDA_ARRAY3D_DESCRIPTOR()
     err = cydriver.cuArray3DGetDescriptor(<cydriver.CUDA_ARRAY3D_DESCRIPTOR*>pArrayDescriptor._pvt_ptr, cyhArray)
-    return (CUresult(err), pArrayDescriptor)
+    return (_dict_CUresult[err], pArrayDescriptor)
 {{endif}}
 
 {{if 'cuMipmappedArrayCreate' in found_functions}}
@@ -31625,7 +31953,7 @@ def cuMipmappedArrayCreate(pMipmappedArrayDesc : Optional[CUDA_ARRAY3D_DESCRIPTO
     cdef CUmipmappedArray pHandle = CUmipmappedArray()
     cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR* cypMipmappedArrayDesc_ptr = pMipmappedArrayDesc._pvt_ptr if pMipmappedArrayDesc != None else NULL
     err = cydriver.cuMipmappedArrayCreate(<cydriver.CUmipmappedArray*>pHandle._pvt_ptr, cypMipmappedArrayDesc_ptr, numMipmapLevels)
-    return (CUresult(err), pHandle)
+    return (_dict_CUresult[err], pHandle)
 {{endif}}
 
 {{if 'cuMipmappedArrayGetLevel' in found_functions}}
@@ -31668,7 +31996,7 @@ def cuMipmappedArrayGetLevel(hMipmappedArray, unsigned int level):
     cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
     cdef CUarray pLevelArray = CUarray()
     err = cydriver.cuMipmappedArrayGetLevel(<cydriver.CUarray*>pLevelArray._pvt_ptr, cyhMipmappedArray, level)
-    return (CUresult(err), pLevelArray)
+    return (_dict_CUresult[err], pLevelArray)
 {{endif}}
 
 {{if 'cuMipmappedArrayDestroy' in found_functions}}
@@ -31702,7 +32030,7 @@ def cuMipmappedArrayDestroy(hMipmappedArray):
         phMipmappedArray = int(CUmipmappedArray(hMipmappedArray))
     cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
     err = cydriver.cuMipmappedArrayDestroy(cyhMipmappedArray)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemGetHandleForAddressRange' in found_functions}}
@@ -31777,7 +32105,7 @@ def cuMemGetHandleForAddressRange(dptr, size_t size, handleType not None : CUmem
     cdef void* cyhandle_ptr = <void*>&handle
     cdef cydriver.CUmemRangeHandleType cyhandleType = handleType.value
     err = cydriver.cuMemGetHandleForAddressRange(cyhandle_ptr, cydptr, size, cyhandleType, flags)
-    return (CUresult(err), handle)
+    return (_dict_CUresult[err], handle)
 {{endif}}
 
 {{if 'cuMemBatchDecompressAsync' in found_functions}}
@@ -31860,7 +32188,7 @@ def cuMemBatchDecompressAsync(paramsArray : Optional[CUmemDecompressParams], siz
     cdef cydriver.CUmemDecompressParams* cyparamsArray_ptr = paramsArray._pvt_ptr if paramsArray != None else NULL
     cdef size_t errorIndex = 0
     err = cydriver.cuMemBatchDecompressAsync(cyparamsArray_ptr, count, flags, &errorIndex, cystream)
-    return (CUresult(err), errorIndex)
+    return (_dict_CUresult[err], errorIndex)
 {{endif}}
 
 {{if 'cuMemAddressReserve' in found_functions}}
@@ -31907,7 +32235,7 @@ def cuMemAddressReserve(size_t size, size_t alignment, addr, unsigned long long
     cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     cdef CUdeviceptr ptr = CUdeviceptr()
     err = cydriver.cuMemAddressReserve(<cydriver.CUdeviceptr*>ptr._pvt_ptr, size, alignment, cyaddr, flags)
-    return (CUresult(err), ptr)
+    return (_dict_CUresult[err], ptr)
 {{endif}}
 
 {{if 'cuMemAddressFree' in found_functions}}
@@ -31945,7 +32273,7 @@ def cuMemAddressFree(ptr, size_t size):
         pptr = int(CUdeviceptr(ptr))
     cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     err = cydriver.cuMemAddressFree(cyptr, size)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemCreate' in found_functions}}
@@ -32028,7 +32356,7 @@ def cuMemCreate(size_t size, prop : Optional[CUmemAllocationProp], unsigned long
     cdef CUmemGenericAllocationHandle handle = CUmemGenericAllocationHandle()
     cdef cydriver.CUmemAllocationProp* cyprop_ptr = prop._pvt_ptr if prop != None else NULL
     err = cydriver.cuMemCreate(<cydriver.CUmemGenericAllocationHandle*>handle._pvt_ptr, size, cyprop_ptr, flags)
-    return (CUresult(err), handle)
+    return (_dict_CUresult[err], handle)
 {{endif}}
 
 {{if 'cuMemRelease' in found_functions}}
@@ -32071,7 +32399,7 @@ def cuMemRelease(handle):
         phandle = int(CUmemGenericAllocationHandle(handle))
     cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     err = cydriver.cuMemRelease(cyhandle)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemMap' in found_functions}}
@@ -32147,7 +32475,7 @@ def cuMemMap(ptr, size_t size, size_t offset, handle, unsigned long long flags):
         pptr = int(CUdeviceptr(ptr))
     cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     err = cydriver.cuMemMap(cyptr, size, offset, cyhandle, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemMapArrayAsync' in found_functions}}
@@ -32318,7 +32646,7 @@ def cuMemMapArrayAsync(mapInfoList : Optional[Tuple[CUarrayMapInfo] | List[CUarr
     err = cydriver.cuMemMapArrayAsync((<CUarrayMapInfo>mapInfoList[0])._pvt_ptr if len(mapInfoList) == 1 else cymapInfoList, count, cyhStream)
     if cymapInfoList is not NULL:
         free(cymapInfoList)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemUnmap' in found_functions}}
@@ -32365,7 +32693,7 @@ def cuMemUnmap(ptr, size_t size):
         pptr = int(CUdeviceptr(ptr))
     cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     err = cydriver.cuMemUnmap(cyptr, size)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemSetAccess' in found_functions}}
@@ -32435,7 +32763,7 @@ def cuMemSetAccess(ptr, size_t size, desc : Optional[Tuple[CUmemAccessDesc] | Li
     err = cydriver.cuMemSetAccess(cyptr, size, (<CUmemAccessDesc>desc[0])._pvt_ptr if len(desc) == 1 else cydesc, count)
     if cydesc is not NULL:
         free(cydesc)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemGetAccess' in found_functions}}
@@ -32473,7 +32801,7 @@ def cuMemGetAccess(location : Optional[CUmemLocation], ptr):
     cdef unsigned long long flags = 0
     cdef cydriver.CUmemLocation* cylocation_ptr = location._pvt_ptr if location != None else NULL
     err = cydriver.cuMemGetAccess(&flags, cylocation_ptr, cyptr)
-    return (CUresult(err), flags)
+    return (_dict_CUresult[err], flags)
 {{endif}}
 
 {{if 'cuMemExportToShareableHandle' in found_functions}}
@@ -32530,7 +32858,7 @@ def cuMemExportToShareableHandle(handle, handleType not None : CUmemAllocationHa
     cdef void* cyshareableHandle_ptr = <void*><void_ptr>cyshareableHandle.cptr
     cdef cydriver.CUmemAllocationHandleType cyhandleType = handleType.value
     err = cydriver.cuMemExportToShareableHandle(cyshareableHandle_ptr, cyhandle, cyhandleType, flags)
-    return (CUresult(err), cyshareableHandle.pyObj())
+    return (_dict_CUresult[err], cyshareableHandle.pyObj())
 {{endif}}
 
 {{if 'cuMemImportFromShareableHandle' in found_functions}}
@@ -32577,7 +32905,7 @@ def cuMemImportFromShareableHandle(osHandle, shHandleType not None : CUmemAlloca
     cdef void* cyosHandle_ptr = <void*><void_ptr>cyosHandle.cptr
     cdef cydriver.CUmemAllocationHandleType cyshHandleType = shHandleType.value
     err = cydriver.cuMemImportFromShareableHandle(<cydriver.CUmemGenericAllocationHandle*>handle._pvt_ptr, cyosHandle_ptr, cyshHandleType)
-    return (CUresult(err), handle)
+    return (_dict_CUresult[err], handle)
 {{endif}}
 
 {{if 'cuMemGetAllocationGranularity' in found_functions}}
@@ -32613,7 +32941,7 @@ def cuMemGetAllocationGranularity(prop : Optional[CUmemAllocationProp], option n
     cdef cydriver.CUmemAllocationProp* cyprop_ptr = prop._pvt_ptr if prop != None else NULL
     cdef cydriver.CUmemAllocationGranularity_flags cyoption = option.value
     err = cydriver.cuMemGetAllocationGranularity(&granularity, cyprop_ptr, cyoption)
-    return (CUresult(err), granularity)
+    return (_dict_CUresult[err], granularity)
 {{endif}}
 
 {{if 'cuMemGetAllocationPropertiesFromHandle' in found_functions}}
@@ -32649,7 +32977,7 @@ def cuMemGetAllocationPropertiesFromHandle(handle):
     cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     cdef CUmemAllocationProp prop = CUmemAllocationProp()
     err = cydriver.cuMemGetAllocationPropertiesFromHandle(<cydriver.CUmemAllocationProp*>prop._pvt_ptr, cyhandle)
-    return (CUresult(err), prop)
+    return (_dict_CUresult[err], prop)
 {{endif}}
 
 {{if 'cuMemRetainAllocationHandle' in found_functions}}
@@ -32687,7 +33015,7 @@ def cuMemRetainAllocationHandle(addr):
     cyaddr = utils.HelperInputVoidPtr(addr)
     cdef void* cyaddr_ptr = <void*><void_ptr>cyaddr.cptr
     err = cydriver.cuMemRetainAllocationHandle(<cydriver.CUmemGenericAllocationHandle*>handle._pvt_ptr, cyaddr_ptr)
-    return (CUresult(err), handle)
+    return (_dict_CUresult[err], handle)
 {{endif}}
 
 {{if 'cuMemFreeAsync' in found_functions}}
@@ -32734,7 +33062,7 @@ def cuMemFreeAsync(dptr, hStream):
         pdptr = int(CUdeviceptr(dptr))
     cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     err = cydriver.cuMemFreeAsync(cydptr, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemAllocAsync' in found_functions}}
@@ -32785,7 +33113,7 @@ def cuMemAllocAsync(size_t bytesize, hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUdeviceptr dptr = CUdeviceptr()
     err = cydriver.cuMemAllocAsync(<cydriver.CUdeviceptr*>dptr._pvt_ptr, bytesize, cyhStream)
-    return (CUresult(err), dptr)
+    return (_dict_CUresult[err], dptr)
 {{endif}}
 
 {{if 'cuMemPoolTrimTo' in found_functions}}
@@ -32834,7 +33162,7 @@ def cuMemPoolTrimTo(pool, size_t minBytesToKeep):
         ppool = int(CUmemoryPool(pool))
     cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     err = cydriver.cuMemPoolTrimTo(cypool, minBytesToKeep)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemPoolSetAttribute' in found_functions}}
@@ -32908,7 +33236,7 @@ def cuMemPoolSetAttribute(pool, attr not None : CUmemPool_attribute, value):
     cdef utils.HelperCUmemPool_attribute cyvalue = utils.HelperCUmemPool_attribute(attr, value, is_getter=False)
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     err = cydriver.cuMemPoolSetAttribute(cypool, cyattr, cyvalue_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemPoolGetAttribute' in found_functions}}
@@ -32989,7 +33317,7 @@ def cuMemPoolGetAttribute(pool, attr not None : CUmemPool_attribute):
     cdef utils.HelperCUmemPool_attribute cyvalue = utils.HelperCUmemPool_attribute(attr, 0, is_getter=True)
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     err = cydriver.cuMemPoolGetAttribute(cypool, cyattr, cyvalue_ptr)
-    return (CUresult(err), cyvalue.pyObj())
+    return (_dict_CUresult[err], cyvalue.pyObj())
 {{endif}}
 
 {{if 'cuMemPoolSetAccess' in found_functions}}
@@ -33039,7 +33367,7 @@ def cuMemPoolSetAccess(pool, map : Optional[Tuple[CUmemAccessDesc] | List[CUmemA
     err = cydriver.cuMemPoolSetAccess(cypool, (<CUmemAccessDesc>map[0])._pvt_ptr if len(map) == 1 else cymap, count)
     if cymap is not NULL:
         free(cymap)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemPoolGetAccess' in found_functions}}
@@ -33080,7 +33408,7 @@ def cuMemPoolGetAccess(memPool, location : Optional[CUmemLocation]):
     cdef cydriver.CUmemAccess_flags flags
     cdef cydriver.CUmemLocation* cylocation_ptr = location._pvt_ptr if location != None else NULL
     err = cydriver.cuMemPoolGetAccess(&flags, cymemPool, cylocation_ptr)
-    return (CUresult(err), CUmemAccess_flags(flags))
+    return (_dict_CUresult[err], CUmemAccess_flags(flags))
 {{endif}}
 
 {{if 'cuMemPoolCreate' in found_functions}}
@@ -33152,7 +33480,7 @@ def cuMemPoolCreate(poolProps : Optional[CUmemPoolProps]):
     cdef CUmemoryPool pool = CUmemoryPool()
     cdef cydriver.CUmemPoolProps* cypoolProps_ptr = poolProps._pvt_ptr if poolProps != None else NULL
     err = cydriver.cuMemPoolCreate(<cydriver.CUmemoryPool*>pool._pvt_ptr, cypoolProps_ptr)
-    return (CUresult(err), pool)
+    return (_dict_CUresult[err], pool)
 {{endif}}
 
 {{if 'cuMemPoolDestroy' in found_functions}}
@@ -33197,7 +33525,7 @@ def cuMemPoolDestroy(pool):
         ppool = int(CUmemoryPool(pool))
     cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     err = cydriver.cuMemPoolDestroy(cypool)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemAllocFromPoolAsync' in found_functions}}
@@ -33253,7 +33581,7 @@ def cuMemAllocFromPoolAsync(size_t bytesize, pool, hStream):
     cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     cdef CUdeviceptr dptr = CUdeviceptr()
     err = cydriver.cuMemAllocFromPoolAsync(<cydriver.CUdeviceptr*>dptr._pvt_ptr, bytesize, cypool, cyhStream)
-    return (CUresult(err), dptr)
+    return (_dict_CUresult[err], dptr)
 {{endif}}
 
 {{if 'cuMemPoolExportToShareableHandle' in found_functions}}
@@ -33307,7 +33635,7 @@ def cuMemPoolExportToShareableHandle(pool, handleType not None : CUmemAllocation
     cdef void* cyhandle_out_ptr = <void*><void_ptr>cyhandle_out.cptr
     cdef cydriver.CUmemAllocationHandleType cyhandleType = handleType.value
     err = cydriver.cuMemPoolExportToShareableHandle(cyhandle_out_ptr, cypool, cyhandleType, flags)
-    return (CUresult(err), cyhandle_out.pyObj())
+    return (_dict_CUresult[err], cyhandle_out.pyObj())
 {{endif}}
 
 {{if 'cuMemPoolImportFromShareableHandle' in found_functions}}
@@ -33353,7 +33681,7 @@ def cuMemPoolImportFromShareableHandle(handle, handleType not None : CUmemAlloca
     cdef void* cyhandle_ptr = <void*><void_ptr>cyhandle.cptr
     cdef cydriver.CUmemAllocationHandleType cyhandleType = handleType.value
     err = cydriver.cuMemPoolImportFromShareableHandle(<cydriver.CUmemoryPool*>pool_out._pvt_ptr, cyhandle_ptr, cyhandleType, flags)
-    return (CUresult(err), pool_out)
+    return (_dict_CUresult[err], pool_out)
 {{endif}}
 
 {{if 'cuMemPoolExportPointer' in found_functions}}
@@ -33393,7 +33721,7 @@ def cuMemPoolExportPointer(ptr):
     cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     cdef CUmemPoolPtrExportData shareData_out = CUmemPoolPtrExportData()
     err = cydriver.cuMemPoolExportPointer(<cydriver.CUmemPoolPtrExportData*>shareData_out._pvt_ptr, cyptr)
-    return (CUresult(err), shareData_out)
+    return (_dict_CUresult[err], shareData_out)
 {{endif}}
 
 {{if 'cuMemPoolImportPointer' in found_functions}}
@@ -33443,7 +33771,7 @@ def cuMemPoolImportPointer(pool, shareData : Optional[CUmemPoolPtrExportData]):
     cdef CUdeviceptr ptr_out = CUdeviceptr()
     cdef cydriver.CUmemPoolPtrExportData* cyshareData_ptr = shareData._pvt_ptr if shareData != None else NULL
     err = cydriver.cuMemPoolImportPointer(<cydriver.CUdeviceptr*>ptr_out._pvt_ptr, cypool, cyshareData_ptr)
-    return (CUresult(err), ptr_out)
+    return (_dict_CUresult[err], ptr_out)
 {{endif}}
 
 {{if 'cuMulticastCreate' in found_functions}}
@@ -33501,7 +33829,7 @@ def cuMulticastCreate(prop : Optional[CUmulticastObjectProp]):
     cdef CUmemGenericAllocationHandle mcHandle = CUmemGenericAllocationHandle()
     cdef cydriver.CUmulticastObjectProp* cyprop_ptr = prop._pvt_ptr if prop != None else NULL
     err = cydriver.cuMulticastCreate(<cydriver.CUmemGenericAllocationHandle*>mcHandle._pvt_ptr, cyprop_ptr)
-    return (CUresult(err), mcHandle)
+    return (_dict_CUresult[err], mcHandle)
 {{endif}}
 
 {{if 'cuMulticastAddDevice' in found_functions}}
@@ -33556,7 +33884,7 @@ def cuMulticastAddDevice(mcHandle, dev):
         pmcHandle = int(CUmemGenericAllocationHandle(mcHandle))
     cymcHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>pmcHandle
     err = cydriver.cuMulticastAddDevice(cymcHandle, cydev)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMulticastBindMem' in found_functions}}
@@ -33630,7 +33958,7 @@ def cuMulticastBindMem(mcHandle, size_t mcOffset, memHandle, size_t memOffset, s
         pmcHandle = int(CUmemGenericAllocationHandle(mcHandle))
     cymcHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>pmcHandle
     err = cydriver.cuMulticastBindMem(cymcHandle, mcOffset, cymemHandle, memOffset, size, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMulticastBindAddr' in found_functions}}
@@ -33700,7 +34028,7 @@ def cuMulticastBindAddr(mcHandle, size_t mcOffset, memptr, size_t size, unsigned
         pmcHandle = int(CUmemGenericAllocationHandle(mcHandle))
     cymcHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>pmcHandle
     err = cydriver.cuMulticastBindAddr(cymcHandle, mcOffset, cymemptr, size, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMulticastUnbind' in found_functions}}
@@ -33758,7 +34086,7 @@ def cuMulticastUnbind(mcHandle, dev, size_t mcOffset, size_t size):
         pmcHandle = int(CUmemGenericAllocationHandle(mcHandle))
     cymcHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>pmcHandle
     err = cydriver.cuMulticastUnbind(cymcHandle, cydev, mcOffset, size)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMulticastGetGranularity' in found_functions}}
@@ -33794,7 +34122,7 @@ def cuMulticastGetGranularity(prop : Optional[CUmulticastObjectProp], option not
     cdef cydriver.CUmulticastObjectProp* cyprop_ptr = prop._pvt_ptr if prop != None else NULL
     cdef cydriver.CUmulticastGranularity_flags cyoption = option.value
     err = cydriver.cuMulticastGetGranularity(&granularity, cyprop_ptr, cyoption)
-    return (CUresult(err), granularity)
+    return (_dict_CUresult[err], granularity)
 {{endif}}
 
 {{if 'cuPointerGetAttribute' in found_functions}}
@@ -34004,7 +34332,7 @@ def cuPointerGetAttribute(attribute not None : CUpointer_attribute, ptr):
     cdef void* cydata_ptr = <void*><void_ptr>cydata.cptr
     cdef cydriver.CUpointer_attribute cyattribute = attribute.value
     err = cydriver.cuPointerGetAttribute(cydata_ptr, cyattribute, cyptr)
-    return (CUresult(err), cydata.pyObj())
+    return (_dict_CUresult[err], cydata.pyObj())
 {{endif}}
 
 {{if 'cuMemPrefetchAsync' in found_functions}}
@@ -34120,7 +34448,7 @@ def cuMemPrefetchAsync(devPtr, size_t count, dstDevice, hStream):
         pdevPtr = int(CUdeviceptr(devPtr))
     cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     err = cydriver.cuMemPrefetchAsync(cydevPtr, count, cydstDevice, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemPrefetchAsync_v2' in found_functions}}
@@ -34241,7 +34569,7 @@ def cuMemPrefetchAsync_v2(devPtr, size_t count, location not None : CUmemLocatio
         pdevPtr = int(CUdeviceptr(devPtr))
     cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     err = cydriver.cuMemPrefetchAsync_v2(cydevPtr, count, location._pvt_ptr[0], flags, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemAdvise' in found_functions}}
@@ -34425,7 +34753,7 @@ def cuMemAdvise(devPtr, size_t count, advice not None : CUmem_advise, device):
     cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     cdef cydriver.CUmem_advise cyadvice = advice.value
     err = cydriver.cuMemAdvise(cydevPtr, count, cyadvice, cydevice)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemAdvise_v2' in found_functions}}
@@ -34630,7 +34958,7 @@ def cuMemAdvise_v2(devPtr, size_t count, advice not None : CUmem_advise, locatio
     cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     cdef cydriver.CUmem_advise cyadvice = advice.value
     err = cydriver.cuMemAdvise_v2(cydevPtr, count, cyadvice, location._pvt_ptr[0])
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuMemRangeGetAttribute' in found_functions}}
@@ -34785,7 +35113,7 @@ def cuMemRangeGetAttribute(size_t dataSize, attribute not None : CUmem_range_att
     cdef void* cydata_ptr = <void*><void_ptr>cydata.cptr
     cdef cydriver.CUmem_range_attribute cyattribute = attribute.value
     err = cydriver.cuMemRangeGetAttribute(cydata_ptr, dataSize, cyattribute, cydevPtr, count)
-    return (CUresult(err), cydata.pyObj())
+    return (_dict_CUresult[err], cydata.pyObj())
 {{endif}}
 
 {{if 'cuMemRangeGetAttributes' in found_functions}}
@@ -34869,7 +35197,7 @@ def cuMemRangeGetAttributes(dataSizes : Tuple[int] | List[int], attributes : Opt
     if numAttributes > <size_t>len(dataSizes): raise RuntimeError("List is too small: " + str(len(dataSizes)) + " < " + str(numAttributes))
     if numAttributes > <size_t>len(attributes): raise RuntimeError("List is too small: " + str(len(attributes)) + " < " + str(numAttributes))
     err = cydriver.cuMemRangeGetAttributes(cyvoidStarHelper_ptr, cydataSizes.data(), cyattributes.data(), numAttributes, cydevPtr, count)
-    return (CUresult(err), [obj.pyObj() for obj in pylist])
+    return (_dict_CUresult[err], [obj.pyObj() for obj in pylist])
 {{endif}}
 
 {{if 'cuPointerSetAttribute' in found_functions}}
@@ -34924,7 +35252,7 @@ def cuPointerSetAttribute(value, attribute not None : CUpointer_attribute, ptr):
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     cdef cydriver.CUpointer_attribute cyattribute = attribute.value
     err = cydriver.cuPointerSetAttribute(cyvalue_ptr, cyattribute, cyptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuPointerGetAttributes' in found_functions}}
@@ -35015,7 +35343,7 @@ def cuPointerGetAttributes(unsigned int numAttributes, attributes : Optional[Tup
     cdef utils.InputVoidPtrPtrHelper voidStarHelperdata = utils.InputVoidPtrPtrHelper(pylist)
     cdef void** cyvoidStarHelper_ptr = <void**><void_ptr>voidStarHelperdata.cptr
     err = cydriver.cuPointerGetAttributes(numAttributes, cyattributes.data(), cyvoidStarHelper_ptr, cyptr)
-    return (CUresult(err), [obj.pyObj() for obj in pylist])
+    return (_dict_CUresult[err], [obj.pyObj() for obj in pylist])
 {{endif}}
 
 {{if 'cuStreamCreate' in found_functions}}
@@ -35054,7 +35382,7 @@ def cuStreamCreate(unsigned int Flags):
     """
     cdef CUstream phStream = CUstream()
     err = cydriver.cuStreamCreate(<cydriver.CUstream*>phStream._pvt_ptr, Flags)
-    return (CUresult(err), phStream)
+    return (_dict_CUresult[err], phStream)
 {{endif}}
 
 {{if 'cuStreamCreateWithPriority' in found_functions}}
@@ -35106,7 +35434,7 @@ def cuStreamCreateWithPriority(unsigned int flags, int priority):
     """
     cdef CUstream phStream = CUstream()
     err = cydriver.cuStreamCreateWithPriority(<cydriver.CUstream*>phStream._pvt_ptr, flags, priority)
-    return (CUresult(err), phStream)
+    return (_dict_CUresult[err], phStream)
 {{endif}}
 
 {{if 'cuStreamGetPriority' in found_functions}}
@@ -35151,7 +35479,7 @@ def cuStreamGetPriority(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef int priority = 0
     err = cydriver.cuStreamGetPriority(cyhStream, &priority)
-    return (CUresult(err), priority)
+    return (_dict_CUresult[err], priority)
 {{endif}}
 
 {{if 'cuStreamGetDevice' in found_functions}}
@@ -35188,7 +35516,7 @@ def cuStreamGetDevice(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUdevice device = CUdevice()
     err = cydriver.cuStreamGetDevice(cyhStream, <cydriver.CUdevice*>device._pvt_ptr)
-    return (CUresult(err), device)
+    return (_dict_CUresult[err], device)
 {{endif}}
 
 {{if 'cuStreamGetFlags' in found_functions}}
@@ -35230,7 +35558,7 @@ def cuStreamGetFlags(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef unsigned int flags = 0
     err = cydriver.cuStreamGetFlags(cyhStream, &flags)
-    return (CUresult(err), flags)
+    return (_dict_CUresult[err], flags)
 {{endif}}
 
 {{if 'cuStreamGetId' in found_functions}}
@@ -35284,7 +35612,7 @@ def cuStreamGetId(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef unsigned long long streamId = 0
     err = cydriver.cuStreamGetId(cyhStream, &streamId)
-    return (CUresult(err), streamId)
+    return (_dict_CUresult[err], streamId)
 {{endif}}
 
 {{if 'cuStreamGetCtx' in found_functions}}
@@ -35347,7 +35675,7 @@ def cuStreamGetCtx(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUcontext pctx = CUcontext()
     err = cydriver.cuStreamGetCtx(cyhStream, <cydriver.CUcontext*>pctx._pvt_ptr)
-    return (CUresult(err), pctx)
+    return (_dict_CUresult[err], pctx)
 {{endif}}
 
 {{if 'cuStreamGetCtx_v2' in found_functions}}
@@ -35422,7 +35750,7 @@ def cuStreamGetCtx_v2(hStream):
     cdef CUcontext pCtx = CUcontext()
     cdef CUgreenCtx pGreenCtx = CUgreenCtx()
     err = cydriver.cuStreamGetCtx_v2(cyhStream, <cydriver.CUcontext*>pCtx._pvt_ptr, <cydriver.CUgreenCtx*>pGreenCtx._pvt_ptr)
-    return (CUresult(err), pCtx, pGreenCtx)
+    return (_dict_CUresult[err], pCtx, pGreenCtx)
 {{endif}}
 
 {{if 'cuStreamWaitEvent' in found_functions}}
@@ -35480,7 +35808,7 @@ def cuStreamWaitEvent(hStream, hEvent, unsigned int Flags):
         phStream = int(CUstream(hStream))
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     err = cydriver.cuStreamWaitEvent(cyhStream, cyhEvent, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamAddCallback' in found_functions}}
@@ -35598,7 +35926,7 @@ def cuStreamAddCallback(hStream, callback, userData, unsigned int flags):
 
     if err != cydriver.CUDA_SUCCESS:
         free(cbData)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamBeginCapture_v2' in found_functions}}
@@ -35653,7 +35981,7 @@ def cuStreamBeginCapture(hStream, mode not None : CUstreamCaptureMode):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef cydriver.CUstreamCaptureMode cymode = mode.value
     err = cydriver.cuStreamBeginCapture(cyhStream, cymode)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamBeginCaptureToGraph' in found_functions}}
@@ -35755,7 +36083,7 @@ def cuStreamBeginCaptureToGraph(hStream, hGraph, dependencies : Optional[Tuple[C
         free(cydependencies)
     if cydependencyData is not NULL:
         free(cydependencyData)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuThreadExchangeStreamCaptureMode' in found_functions}}
@@ -35826,7 +36154,7 @@ def cuThreadExchangeStreamCaptureMode(mode not None : CUstreamCaptureMode):
     """
     cdef cydriver.CUstreamCaptureMode cymode = mode.value
     err = cydriver.cuThreadExchangeStreamCaptureMode(&cymode)
-    return (CUresult(err), CUstreamCaptureMode(cymode))
+    return (_dict_CUresult[err], CUstreamCaptureMode(cymode))
 {{endif}}
 
 {{if 'cuStreamEndCapture' in found_functions}}
@@ -35871,7 +36199,7 @@ def cuStreamEndCapture(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUgraph phGraph = CUgraph()
     err = cydriver.cuStreamEndCapture(cyhStream, <cydriver.CUgraph*>phGraph._pvt_ptr)
-    return (CUresult(err), phGraph)
+    return (_dict_CUresult[err], phGraph)
 {{endif}}
 
 {{if 'cuStreamIsCapturing' in found_functions}}
@@ -35931,7 +36259,7 @@ def cuStreamIsCapturing(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef cydriver.CUstreamCaptureStatus captureStatus
     err = cydriver.cuStreamIsCapturing(cyhStream, &captureStatus)
-    return (CUresult(err), CUstreamCaptureStatus(captureStatus))
+    return (_dict_CUresult[err], CUstreamCaptureStatus(captureStatus))
 {{endif}}
 
 {{if 'cuStreamGetCaptureInfo_v2' in found_functions}}
@@ -36012,7 +36340,7 @@ def cuStreamGetCaptureInfo(hStream):
     err = cydriver.cuStreamGetCaptureInfo(cyhStream, &captureStatus_out, <cydriver.cuuint64_t*>id_out._pvt_ptr, <cydriver.CUgraph*>graph_out._pvt_ptr, &cydependencies_out, &numDependencies_out)
     if CUresult(err) == CUresult(0):
         pydependencies_out = [CUgraphNode(init_value=<void_ptr>cydependencies_out[idx]) for idx in range(numDependencies_out)]
-    return (CUresult(err), CUstreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, numDependencies_out)
+    return (_dict_CUresult[err], CUstreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, numDependencies_out)
 {{endif}}
 
 {{if 'cuStreamGetCaptureInfo_v3' in found_functions}}
@@ -36109,7 +36437,7 @@ def cuStreamGetCaptureInfo_v3(hStream):
         pydependencies_out = [CUgraphNode(init_value=<void_ptr>cydependencies_out[idx]) for idx in range(numDependencies_out)]
     if CUresult(err) == CUresult(0):
         pyedgeData_out = [CUgraphEdgeData(_ptr=<void_ptr>&cyedgeData_out[idx]) for idx in range(numDependencies_out)]
-    return (CUresult(err), CUstreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, pyedgeData_out, numDependencies_out)
+    return (_dict_CUresult[err], CUstreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, pyedgeData_out, numDependencies_out)
 {{endif}}
 
 {{if 'cuStreamUpdateCaptureDependencies' in found_functions}}
@@ -36182,7 +36510,7 @@ def cuStreamUpdateCaptureDependencies(hStream, dependencies : Optional[Tuple[CUg
     err = cydriver.cuStreamUpdateCaptureDependencies(cyhStream, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, flags)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamUpdateCaptureDependencies_v2' in found_functions}}
@@ -36264,7 +36592,7 @@ def cuStreamUpdateCaptureDependencies_v2(hStream, dependencies : Optional[Tuple[
         free(cydependencies)
     if cydependencyData is not NULL:
         free(cydependencyData)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamAttachMemAsync' in found_functions}}
@@ -36376,7 +36704,7 @@ def cuStreamAttachMemAsync(hStream, dptr, size_t length, unsigned int flags):
         phStream = int(CUstream(hStream))
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     err = cydriver.cuStreamAttachMemAsync(cyhStream, cydptr, length, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamQuery' in found_functions}}
@@ -36416,7 +36744,7 @@ def cuStreamQuery(hStream):
         phStream = int(CUstream(hStream))
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     err = cydriver.cuStreamQuery(cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamSynchronize' in found_functions}}
@@ -36455,7 +36783,7 @@ def cuStreamSynchronize(hStream):
         phStream = int(CUstream(hStream))
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     err = cydriver.cuStreamSynchronize(cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamDestroy_v2' in found_functions}}
@@ -36495,7 +36823,7 @@ def cuStreamDestroy(hStream):
         phStream = int(CUstream(hStream))
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     err = cydriver.cuStreamDestroy(cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamCopyAttributes' in found_functions}}
@@ -36540,7 +36868,7 @@ def cuStreamCopyAttributes(dst, src):
         pdst = int(CUstream(dst))
     cydst = <cydriver.CUstream><void_ptr>pdst
     err = cydriver.cuStreamCopyAttributes(cydst, cysrc)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamGetAttribute' in found_functions}}
@@ -36581,7 +36909,7 @@ def cuStreamGetAttribute(hStream, attr not None : CUstreamAttrID):
     cdef cydriver.CUstreamAttrID cyattr = attr.value
     cdef CUstreamAttrValue value_out = CUstreamAttrValue()
     err = cydriver.cuStreamGetAttribute(cyhStream, cyattr, <cydriver.CUstreamAttrValue*>value_out._pvt_ptr)
-    return (CUresult(err), value_out)
+    return (_dict_CUresult[err], value_out)
 {{endif}}
 
 {{if 'cuStreamSetAttribute' in found_functions}}
@@ -36623,7 +36951,7 @@ def cuStreamSetAttribute(hStream, attr not None : CUstreamAttrID, value : Option
     cdef cydriver.CUstreamAttrID cyattr = attr.value
     cdef cydriver.CUstreamAttrValue* cyvalue_ptr = value._pvt_ptr if value != None else NULL
     err = cydriver.cuStreamSetAttribute(cyhStream, cyattr, cyvalue_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuEventCreate' in found_functions}}
@@ -36671,7 +36999,7 @@ def cuEventCreate(unsigned int Flags):
     """
     cdef CUevent phEvent = CUevent()
     err = cydriver.cuEventCreate(<cydriver.CUevent*>phEvent._pvt_ptr, Flags)
-    return (CUresult(err), phEvent)
+    return (_dict_CUresult[err], phEvent)
 {{endif}}
 
 {{if 'cuEventRecord' in found_functions}}
@@ -36730,7 +37058,7 @@ def cuEventRecord(hEvent, hStream):
         phEvent = int(CUevent(hEvent))
     cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     err = cydriver.cuEventRecord(cyhEvent, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuEventRecordWithFlags' in found_functions}}
@@ -36799,7 +37127,7 @@ def cuEventRecordWithFlags(hEvent, hStream, unsigned int flags):
         phEvent = int(CUevent(hEvent))
     cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     err = cydriver.cuEventRecordWithFlags(cyhEvent, cyhStream, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuEventQuery' in found_functions}}
@@ -36843,7 +37171,7 @@ def cuEventQuery(hEvent):
         phEvent = int(CUevent(hEvent))
     cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     err = cydriver.cuEventQuery(cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuEventSynchronize' in found_functions}}
@@ -36886,7 +37214,7 @@ def cuEventSynchronize(hEvent):
         phEvent = int(CUevent(hEvent))
     cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     err = cydriver.cuEventSynchronize(cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuEventDestroy_v2' in found_functions}}
@@ -36926,7 +37254,7 @@ def cuEventDestroy(hEvent):
         phEvent = int(CUevent(hEvent))
     cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     err = cydriver.cuEventDestroy(cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuEventElapsedTime' in found_functions}}
@@ -36996,7 +37324,7 @@ def cuEventElapsedTime(hStart, hEnd):
     cyhStart = <cydriver.CUevent><void_ptr>phStart
     cdef float pMilliseconds = 0
     err = cydriver.cuEventElapsedTime(&pMilliseconds, cyhStart, cyhEnd)
-    return (CUresult(err), pMilliseconds)
+    return (_dict_CUresult[err], pMilliseconds)
 {{endif}}
 
 {{if 'cuEventElapsedTime_v2' in found_functions}}
@@ -37066,7 +37394,7 @@ def cuEventElapsedTime_v2(hStart, hEnd):
     cyhStart = <cydriver.CUevent><void_ptr>phStart
     cdef float pMilliseconds = 0
     err = cydriver.cuEventElapsedTime_v2(&pMilliseconds, cyhStart, cyhEnd)
-    return (CUresult(err), pMilliseconds)
+    return (_dict_CUresult[err], pMilliseconds)
 {{endif}}
 
 {{if 'cuImportExternalMemory' in found_functions}}
@@ -37219,7 +37547,7 @@ def cuImportExternalMemory(memHandleDesc : Optional[CUDA_EXTERNAL_MEMORY_HANDLE_
     cdef CUexternalMemory extMem_out = CUexternalMemory()
     cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC* cymemHandleDesc_ptr = memHandleDesc._pvt_ptr if memHandleDesc != None else NULL
     err = cydriver.cuImportExternalMemory(<cydriver.CUexternalMemory*>extMem_out._pvt_ptr, cymemHandleDesc_ptr)
-    return (CUresult(err), extMem_out)
+    return (_dict_CUresult[err], extMem_out)
 {{endif}}
 
 {{if 'cuExternalMemoryGetMappedBuffer' in found_functions}}
@@ -37286,7 +37614,7 @@ def cuExternalMemoryGetMappedBuffer(extMem, bufferDesc : Optional[CUDA_EXTERNAL_
     cdef CUdeviceptr devPtr = CUdeviceptr()
     cdef cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC* cybufferDesc_ptr = bufferDesc._pvt_ptr if bufferDesc != None else NULL
     err = cydriver.cuExternalMemoryGetMappedBuffer(<cydriver.CUdeviceptr*>devPtr._pvt_ptr, cyextMem, cybufferDesc_ptr)
-    return (CUresult(err), devPtr)
+    return (_dict_CUresult[err], devPtr)
 {{endif}}
 
 {{if 'cuExternalMemoryGetMappedMipmappedArray' in found_functions}}
@@ -37356,7 +37684,7 @@ def cuExternalMemoryGetMappedMipmappedArray(extMem, mipmapDesc : Optional[CUDA_E
     cdef CUmipmappedArray mipmap = CUmipmappedArray()
     cdef cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC* cymipmapDesc_ptr = mipmapDesc._pvt_ptr if mipmapDesc != None else NULL
     err = cydriver.cuExternalMemoryGetMappedMipmappedArray(<cydriver.CUmipmappedArray*>mipmap._pvt_ptr, cyextMem, cymipmapDesc_ptr)
-    return (CUresult(err), mipmap)
+    return (_dict_CUresult[err], mipmap)
 {{endif}}
 
 {{if 'cuDestroyExternalMemory' in found_functions}}
@@ -37393,7 +37721,7 @@ def cuDestroyExternalMemory(extMem):
         pextMem = int(CUexternalMemory(extMem))
     cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
     err = cydriver.cuDestroyExternalMemory(cyextMem)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuImportExternalSemaphore' in found_functions}}
@@ -37541,7 +37869,7 @@ def cuImportExternalSemaphore(semHandleDesc : Optional[CUDA_EXTERNAL_SEMAPHORE_H
     cdef CUexternalSemaphore extSem_out = CUexternalSemaphore()
     cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC* cysemHandleDesc_ptr = semHandleDesc._pvt_ptr if semHandleDesc != None else NULL
     err = cydriver.cuImportExternalSemaphore(<cydriver.CUexternalSemaphore*>extSem_out._pvt_ptr, cysemHandleDesc_ptr)
-    return (CUresult(err), extSem_out)
+    return (_dict_CUresult[err], extSem_out)
 {{endif}}
 
 {{if 'cuSignalExternalSemaphoresAsync' in found_functions}}
@@ -37675,7 +38003,7 @@ def cuSignalExternalSemaphoresAsync(extSemArray : Optional[Tuple[CUexternalSemap
         free(cyextSemArray)
     if cyparamsArray is not NULL:
         free(cyparamsArray)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuWaitExternalSemaphoresAsync' in found_functions}}
@@ -37800,7 +38128,7 @@ def cuWaitExternalSemaphoresAsync(extSemArray : Optional[Tuple[CUexternalSemapho
         free(cyextSemArray)
     if cyparamsArray is not NULL:
         free(cyparamsArray)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDestroyExternalSemaphore' in found_functions}}
@@ -37836,7 +38164,7 @@ def cuDestroyExternalSemaphore(extSem):
         pextSem = int(CUexternalSemaphore(extSem))
     cyextSem = <cydriver.CUexternalSemaphore><void_ptr>pextSem
     err = cydriver.cuDestroyExternalSemaphore(cyextSem)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamWaitValue32_v2' in found_functions}}
@@ -37909,7 +38237,7 @@ def cuStreamWaitValue32(stream, addr, value, unsigned int flags):
         pstream = int(CUstream(stream))
     cystream = <cydriver.CUstream><void_ptr>pstream
     err = cydriver.cuStreamWaitValue32(cystream, cyaddr, cyvalue, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamWaitValue64_v2' in found_functions}}
@@ -37980,7 +38308,7 @@ def cuStreamWaitValue64(stream, addr, value, unsigned int flags):
         pstream = int(CUstream(stream))
     cystream = <cydriver.CUstream><void_ptr>pstream
     err = cydriver.cuStreamWaitValue64(cystream, cyaddr, cyvalue, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamWriteValue32_v2' in found_functions}}
@@ -38041,7 +38369,7 @@ def cuStreamWriteValue32(stream, addr, value, unsigned int flags):
         pstream = int(CUstream(stream))
     cystream = <cydriver.CUstream><void_ptr>pstream
     err = cydriver.cuStreamWriteValue32(cystream, cyaddr, cyvalue, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamWriteValue64_v2' in found_functions}}
@@ -38104,7 +38432,7 @@ def cuStreamWriteValue64(stream, addr, value, unsigned int flags):
         pstream = int(CUstream(stream))
     cystream = <cydriver.CUstream><void_ptr>pstream
     err = cydriver.cuStreamWriteValue64(cystream, cyaddr, cyvalue, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamBatchMemOp_v2' in found_functions}}
@@ -38174,7 +38502,7 @@ def cuStreamBatchMemOp(stream, unsigned int count, paramArray : Optional[Tuple[C
     err = cydriver.cuStreamBatchMemOp(cystream, count, (<CUstreamBatchMemOpParams>paramArray[0])._pvt_ptr if len(paramArray) == 1 else cyparamArray, flags)
     if cyparamArray is not NULL:
         free(cyparamArray)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuFuncGetAttribute' in found_functions}}
@@ -38307,7 +38635,7 @@ def cuFuncGetAttribute(attrib not None : CUfunction_attribute, hfunc):
     cdef int pi = 0
     cdef cydriver.CUfunction_attribute cyattrib = attrib.value
     err = cydriver.cuFuncGetAttribute(&pi, cyattrib, cyhfunc)
-    return (CUresult(err), pi)
+    return (_dict_CUresult[err], pi)
 {{endif}}
 
 {{if 'cuFuncSetAttribute' in found_functions}}
@@ -38400,7 +38728,7 @@ def cuFuncSetAttribute(hfunc, attrib not None : CUfunction_attribute, int value)
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef cydriver.CUfunction_attribute cyattrib = attrib.value
     err = cydriver.cuFuncSetAttribute(cyhfunc, cyattrib, value)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuFuncSetCacheConfig' in found_functions}}
@@ -38465,7 +38793,7 @@ def cuFuncSetCacheConfig(hfunc, config not None : CUfunc_cache):
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef cydriver.CUfunc_cache cyconfig = config.value
     err = cydriver.cuFuncSetCacheConfig(cyhfunc, cyconfig)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuFuncGetModule' in found_functions}}
@@ -38506,7 +38834,7 @@ def cuFuncGetModule(hfunc):
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef CUmodule hmod = CUmodule()
     err = cydriver.cuFuncGetModule(<cydriver.CUmodule*>hmod._pvt_ptr, cyhfunc)
-    return (CUresult(err), hmod)
+    return (_dict_CUresult[err], hmod)
 {{endif}}
 
 {{if 'cuFuncGetName' in found_functions}}
@@ -38545,7 +38873,7 @@ def cuFuncGetName(hfunc):
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef const char* name = NULL
     err = cydriver.cuFuncGetName(&name, cyhfunc)
-    return (CUresult(err), <bytes>name if name != NULL else None)
+    return (_dict_CUresult[err], <bytes>name if name != NULL else None)
 {{endif}}
 
 {{if 'cuFuncGetParamInfo' in found_functions}}
@@ -38597,7 +38925,7 @@ def cuFuncGetParamInfo(func, size_t paramIndex):
     cdef size_t paramOffset = 0
     cdef size_t paramSize = 0
     err = cydriver.cuFuncGetParamInfo(cyfunc, paramIndex, &paramOffset, &paramSize)
-    return (CUresult(err), paramOffset, paramSize)
+    return (_dict_CUresult[err], paramOffset, paramSize)
 {{endif}}
 
 {{if 'cuFuncIsLoaded' in found_functions}}
@@ -38634,7 +38962,7 @@ def cuFuncIsLoaded(function):
     cyfunction = <cydriver.CUfunction><void_ptr>pfunction
     cdef cydriver.CUfunctionLoadingState state
     err = cydriver.cuFuncIsLoaded(&state, cyfunction)
-    return (CUresult(err), CUfunctionLoadingState(state))
+    return (_dict_CUresult[err], CUfunctionLoadingState(state))
 {{endif}}
 
 {{if 'cuFuncLoad' in found_functions}}
@@ -38669,7 +38997,7 @@ def cuFuncLoad(function):
         pfunction = int(CUfunction(function))
     cyfunction = <cydriver.CUfunction><void_ptr>pfunction
     err = cydriver.cuFuncLoad(cyfunction)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchKernel' in found_functions}}
@@ -38800,7 +39128,7 @@ def cuLaunchKernel(f, unsigned int gridDimX, unsigned int gridDimY, unsigned int
     cyf = <cydriver.CUfunction><void_ptr>pf
     cykernelParams = utils.HelperKernelParams(kernelParams)
     err = cydriver.cuLaunchKernel(cyf, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, cyhStream, <void**><void_ptr>cykernelParams.ckernelParams, <void**>extra)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchKernelEx' in found_functions}}
@@ -39039,7 +39367,7 @@ def cuLaunchKernelEx(config : Optional[CUlaunchConfig], f, kernelParams, void_pt
     cdef cydriver.CUlaunchConfig* cyconfig_ptr = config._pvt_ptr if config != None else NULL
     cykernelParams = utils.HelperKernelParams(kernelParams)
     err = cydriver.cuLaunchKernelEx(cyconfig_ptr, cyf, <void**><void_ptr>cykernelParams.ckernelParams, <void**>extra)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchCooperativeKernel' in found_functions}}
@@ -39150,7 +39478,7 @@ def cuLaunchCooperativeKernel(f, unsigned int gridDimX, unsigned int gridDimY, u
     cyf = <cydriver.CUfunction><void_ptr>pf
     cykernelParams = utils.HelperKernelParams(kernelParams)
     err = cydriver.cuLaunchCooperativeKernel(cyf, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, cyhStream, <void**><void_ptr>cykernelParams.ckernelParams)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchCooperativeKernelMultiDevice' in found_functions}}
@@ -39321,7 +39649,7 @@ def cuLaunchCooperativeKernelMultiDevice(launchParamsList : Optional[Tuple[CUDA_
     err = cydriver.cuLaunchCooperativeKernelMultiDevice((<CUDA_LAUNCH_PARAMS>launchParamsList[0])._pvt_ptr if len(launchParamsList) == 1 else cylaunchParamsList, numDevices, flags)
     if cylaunchParamsList is not NULL:
         free(cylaunchParamsList)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchHostFunc' in found_functions}}
@@ -39431,7 +39759,7 @@ def cuLaunchHostFunc(hStream, fn, userData):
 
     if err != cydriver.CUDA_SUCCESS:
         free(cbData)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuFuncSetBlockShape' in found_functions}}
@@ -39474,7 +39802,7 @@ def cuFuncSetBlockShape(hfunc, int x, int y, int z):
         phfunc = int(CUfunction(hfunc))
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     err = cydriver.cuFuncSetBlockShape(cyhfunc, x, y, z)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuFuncSetSharedSize' in found_functions}}
@@ -39514,7 +39842,7 @@ def cuFuncSetSharedSize(hfunc, unsigned int numbytes):
         phfunc = int(CUfunction(hfunc))
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     err = cydriver.cuFuncSetSharedSize(cyhfunc, numbytes)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuParamSetSize' in found_functions}}
@@ -39553,7 +39881,7 @@ def cuParamSetSize(hfunc, unsigned int numbytes):
         phfunc = int(CUfunction(hfunc))
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     err = cydriver.cuParamSetSize(cyhfunc, numbytes)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuParamSeti' in found_functions}}
@@ -39595,7 +39923,7 @@ def cuParamSeti(hfunc, int offset, unsigned int value):
         phfunc = int(CUfunction(hfunc))
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     err = cydriver.cuParamSeti(cyhfunc, offset, value)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuParamSetf' in found_functions}}
@@ -39637,7 +39965,7 @@ def cuParamSetf(hfunc, int offset, float value):
         phfunc = int(CUfunction(hfunc))
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     err = cydriver.cuParamSetf(cyhfunc, offset, value)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuParamSetv' in found_functions}}
@@ -39683,7 +40011,7 @@ def cuParamSetv(hfunc, int offset, ptr, unsigned int numbytes):
     cyptr = utils.HelperInputVoidPtr(ptr)
     cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     err = cydriver.cuParamSetv(cyhfunc, offset, cyptr_ptr, numbytes)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunch' in found_functions}}
@@ -39733,7 +40061,7 @@ def cuLaunch(f):
         pf = int(CUfunction(f))
     cyf = <cydriver.CUfunction><void_ptr>pf
     err = cydriver.cuLaunch(cyf)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchGrid' in found_functions}}
@@ -39787,7 +40115,7 @@ def cuLaunchGrid(f, int grid_width, int grid_height):
         pf = int(CUfunction(f))
     cyf = <cydriver.CUfunction><void_ptr>pf
     err = cydriver.cuLaunchGrid(cyf, grid_width, grid_height)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuLaunchGridAsync' in found_functions}}
@@ -39857,7 +40185,7 @@ def cuLaunchGridAsync(f, int grid_width, int grid_height, hStream):
         pf = int(CUfunction(f))
     cyf = <cydriver.CUfunction><void_ptr>pf
     err = cydriver.cuLaunchGridAsync(cyf, grid_width, grid_height, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuParamSetTexRef' in found_functions}}
@@ -39905,7 +40233,7 @@ def cuParamSetTexRef(hfunc, int texunit, hTexRef):
         phfunc = int(CUfunction(hfunc))
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     err = cydriver.cuParamSetTexRef(cyhfunc, texunit, cyhTexRef)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuFuncSetSharedMemConfig' in found_functions}}
@@ -39977,7 +40305,7 @@ def cuFuncSetSharedMemConfig(hfunc, config not None : CUsharedconfig):
     cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef cydriver.CUsharedconfig cyconfig = config.value
     err = cydriver.cuFuncSetSharedMemConfig(cyhfunc, cyconfig)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphCreate' in found_functions}}
@@ -40006,7 +40334,7 @@ def cuGraphCreate(unsigned int flags):
     """
     cdef CUgraph phGraph = CUgraph()
     err = cydriver.cuGraphCreate(<cydriver.CUgraph*>phGraph._pvt_ptr, flags)
-    return (CUresult(err), phGraph)
+    return (_dict_CUresult[err], phGraph)
 {{endif}}
 
 {{if 'cuGraphAddKernelNode_v2' in found_functions}}
@@ -40125,7 +40453,7 @@ def cuGraphAddKernelNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | Li
     err = cydriver.cuGraphAddKernelNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphKernelNodeGetParams_v2' in found_functions}}
@@ -40171,7 +40499,7 @@ def cuGraphKernelNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_KERNEL_NODE_PARAMS nodeParams = CUDA_KERNEL_NODE_PARAMS()
     err = cydriver.cuGraphKernelNodeGetParams(cyhNode, <cydriver.CUDA_KERNEL_NODE_PARAMS*>nodeParams._pvt_ptr)
-    return (CUresult(err), nodeParams)
+    return (_dict_CUresult[err], nodeParams)
 {{endif}}
 
 {{if 'cuGraphKernelNodeSetParams_v2' in found_functions}}
@@ -40208,7 +40536,7 @@ def cuGraphKernelNodeSetParams(hNode, nodeParams : Optional[CUDA_KERNEL_NODE_PAR
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_KERNEL_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphKernelNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddMemcpyNode' in found_functions}}
@@ -40294,7 +40622,7 @@ def cuGraphAddMemcpyNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | Li
     err = cydriver.cuGraphAddMemcpyNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cycopyParams_ptr, cyctx)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphMemcpyNodeGetParams' in found_functions}}
@@ -40331,7 +40659,7 @@ def cuGraphMemcpyNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_MEMCPY3D nodeParams = CUDA_MEMCPY3D()
     err = cydriver.cuGraphMemcpyNodeGetParams(cyhNode, <cydriver.CUDA_MEMCPY3D*>nodeParams._pvt_ptr)
-    return (CUresult(err), nodeParams)
+    return (_dict_CUresult[err], nodeParams)
 {{endif}}
 
 {{if 'cuGraphMemcpyNodeSetParams' in found_functions}}
@@ -40368,7 +40696,7 @@ def cuGraphMemcpyNodeSetParams(hNode, nodeParams : Optional[CUDA_MEMCPY3D]):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_MEMCPY3D* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphMemcpyNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddMemsetNode' in found_functions}}
@@ -40444,7 +40772,7 @@ def cuGraphAddMemsetNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | Li
     err = cydriver.cuGraphAddMemsetNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cymemsetParams_ptr, cyctx)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphMemsetNodeGetParams' in found_functions}}
@@ -40481,7 +40809,7 @@ def cuGraphMemsetNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_MEMSET_NODE_PARAMS nodeParams = CUDA_MEMSET_NODE_PARAMS()
     err = cydriver.cuGraphMemsetNodeGetParams(cyhNode, <cydriver.CUDA_MEMSET_NODE_PARAMS*>nodeParams._pvt_ptr)
-    return (CUresult(err), nodeParams)
+    return (_dict_CUresult[err], nodeParams)
 {{endif}}
 
 {{if 'cuGraphMemsetNodeSetParams' in found_functions}}
@@ -40518,7 +40846,7 @@ def cuGraphMemsetNodeSetParams(hNode, nodeParams : Optional[CUDA_MEMSET_NODE_PAR
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_MEMSET_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphMemsetNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddHostNode' in found_functions}}
@@ -40584,7 +40912,7 @@ def cuGraphAddHostNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List
     err = cydriver.cuGraphAddHostNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphHostNodeGetParams' in found_functions}}
@@ -40621,7 +40949,7 @@ def cuGraphHostNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_HOST_NODE_PARAMS nodeParams = CUDA_HOST_NODE_PARAMS()
     err = cydriver.cuGraphHostNodeGetParams(cyhNode, <cydriver.CUDA_HOST_NODE_PARAMS*>nodeParams._pvt_ptr)
-    return (CUresult(err), nodeParams)
+    return (_dict_CUresult[err], nodeParams)
 {{endif}}
 
 {{if 'cuGraphHostNodeSetParams' in found_functions}}
@@ -40658,7 +40986,7 @@ def cuGraphHostNodeSetParams(hNode, nodeParams : Optional[CUDA_HOST_NODE_PARAMS]
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_HOST_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphHostNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddChildGraphNode' in found_functions}}
@@ -40734,7 +41062,7 @@ def cuGraphAddChildGraphNode(hGraph, dependencies : Optional[Tuple[CUgraphNode]
     err = cydriver.cuGraphAddChildGraphNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cychildGraph)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphChildGraphNodeGetGraph' in found_functions}}
@@ -40776,7 +41104,7 @@ def cuGraphChildGraphNodeGetGraph(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUgraph phGraph = CUgraph()
     err = cydriver.cuGraphChildGraphNodeGetGraph(cyhNode, <cydriver.CUgraph*>phGraph._pvt_ptr)
-    return (CUresult(err), phGraph)
+    return (_dict_CUresult[err], phGraph)
 {{endif}}
 
 {{if 'cuGraphAddEmptyNode' in found_functions}}
@@ -40842,7 +41170,7 @@ def cuGraphAddEmptyNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | Lis
     err = cydriver.cuGraphAddEmptyNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphAddEventRecordNode' in found_functions}}
@@ -40915,7 +41243,7 @@ def cuGraphAddEventRecordNode(hGraph, dependencies : Optional[Tuple[CUgraphNode]
     err = cydriver.cuGraphAddEventRecordNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cyevent)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphEventRecordNodeGetEvent' in found_functions}}
@@ -40952,7 +41280,7 @@ def cuGraphEventRecordNodeGetEvent(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUevent event_out = CUevent()
     err = cydriver.cuGraphEventRecordNodeGetEvent(cyhNode, <cydriver.CUevent*>event_out._pvt_ptr)
-    return (CUresult(err), event_out)
+    return (_dict_CUresult[err], event_out)
 {{endif}}
 
 {{if 'cuGraphEventRecordNodeSetEvent' in found_functions}}
@@ -40996,7 +41324,7 @@ def cuGraphEventRecordNodeSetEvent(hNode, event):
         phNode = int(CUgraphNode(hNode))
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     err = cydriver.cuGraphEventRecordNodeSetEvent(cyhNode, cyevent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddEventWaitNode' in found_functions}}
@@ -41071,7 +41399,7 @@ def cuGraphAddEventWaitNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] |
     err = cydriver.cuGraphAddEventWaitNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cyevent)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphEventWaitNodeGetEvent' in found_functions}}
@@ -41108,7 +41436,7 @@ def cuGraphEventWaitNodeGetEvent(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUevent event_out = CUevent()
     err = cydriver.cuGraphEventWaitNodeGetEvent(cyhNode, <cydriver.CUevent*>event_out._pvt_ptr)
-    return (CUresult(err), event_out)
+    return (_dict_CUresult[err], event_out)
 {{endif}}
 
 {{if 'cuGraphEventWaitNodeSetEvent' in found_functions}}
@@ -41152,7 +41480,7 @@ def cuGraphEventWaitNodeSetEvent(hNode, event):
         phNode = int(CUgraphNode(hNode))
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     err = cydriver.cuGraphEventWaitNodeSetEvent(cyhNode, cyevent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddExternalSemaphoresSignalNode' in found_functions}}
@@ -41219,7 +41547,7 @@ def cuGraphAddExternalSemaphoresSignalNode(hGraph, dependencies : Optional[Tuple
     err = cydriver.cuGraphAddExternalSemaphoresSignalNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
@@ -41262,7 +41590,7 @@ def cuGraphExternalSemaphoresSignalNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_EXT_SEM_SIGNAL_NODE_PARAMS params_out = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS()
     err = cydriver.cuGraphExternalSemaphoresSignalNodeGetParams(cyhNode, <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>params_out._pvt_ptr)
-    return (CUresult(err), params_out)
+    return (_dict_CUresult[err], params_out)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
@@ -41300,7 +41628,7 @@ def cuGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[CU
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExternalSemaphoresSignalNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddExternalSemaphoresWaitNode' in found_functions}}
@@ -41367,7 +41695,7 @@ def cuGraphAddExternalSemaphoresWaitNode(hGraph, dependencies : Optional[Tuple[C
     err = cydriver.cuGraphAddExternalSemaphoresWaitNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
@@ -41410,7 +41738,7 @@ def cuGraphExternalSemaphoresWaitNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_EXT_SEM_WAIT_NODE_PARAMS params_out = CUDA_EXT_SEM_WAIT_NODE_PARAMS()
     err = cydriver.cuGraphExternalSemaphoresWaitNodeGetParams(cyhNode, <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>params_out._pvt_ptr)
-    return (CUresult(err), params_out)
+    return (_dict_CUresult[err], params_out)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
@@ -41448,7 +41776,7 @@ def cuGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[CUDA
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExternalSemaphoresWaitNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddBatchMemOpNode' in found_functions}}
@@ -41518,7 +41846,7 @@ def cuGraphAddBatchMemOpNode(hGraph, dependencies : Optional[Tuple[CUgraphNode]
     err = cydriver.cuGraphAddBatchMemOpNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphBatchMemOpNodeGetParams' in found_functions}}
@@ -41560,7 +41888,7 @@ def cuGraphBatchMemOpNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_BATCH_MEM_OP_NODE_PARAMS nodeParams_out = CUDA_BATCH_MEM_OP_NODE_PARAMS()
     err = cydriver.cuGraphBatchMemOpNodeGetParams(cyhNode, <cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS*>nodeParams_out._pvt_ptr)
-    return (CUresult(err), nodeParams_out)
+    return (_dict_CUresult[err], nodeParams_out)
 {{endif}}
 
 {{if 'cuGraphBatchMemOpNodeSetParams' in found_functions}}
@@ -41600,7 +41928,7 @@ def cuGraphBatchMemOpNodeSetParams(hNode, nodeParams : Optional[CUDA_BATCH_MEM_O
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphBatchMemOpNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecBatchMemOpNodeSetParams' in found_functions}}
@@ -41670,7 +41998,7 @@ def cuGraphExecBatchMemOpNodeSetParams(hGraphExec, hNode, nodeParams : Optional[
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExecBatchMemOpNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddMemAllocNode' in found_functions}}
@@ -41776,7 +42104,7 @@ def cuGraphAddMemAllocNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] |
     err = cydriver.cuGraphAddMemAllocNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphMemAllocNodeGetParams' in found_functions}}
@@ -41816,7 +42144,7 @@ def cuGraphMemAllocNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_MEM_ALLOC_NODE_PARAMS params_out = CUDA_MEM_ALLOC_NODE_PARAMS()
     err = cydriver.cuGraphMemAllocNodeGetParams(cyhNode, <cydriver.CUDA_MEM_ALLOC_NODE_PARAMS*>params_out._pvt_ptr)
-    return (CUresult(err), params_out)
+    return (_dict_CUresult[err], params_out)
 {{endif}}
 
 {{if 'cuGraphAddMemFreeNode' in found_functions}}
@@ -41906,7 +42234,7 @@ def cuGraphAddMemFreeNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | L
     err = cydriver.cuGraphAddMemFreeNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cydptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphMemFreeNodeGetParams' in found_functions}}
@@ -41943,7 +42271,7 @@ def cuGraphMemFreeNodeGetParams(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUdeviceptr dptr_out = CUdeviceptr()
     err = cydriver.cuGraphMemFreeNodeGetParams(cyhNode, <cydriver.CUdeviceptr*>dptr_out._pvt_ptr)
-    return (CUresult(err), dptr_out)
+    return (_dict_CUresult[err], dptr_out)
 {{endif}}
 
 {{if 'cuDeviceGraphMemTrim' in found_functions}}
@@ -41979,7 +42307,7 @@ def cuDeviceGraphMemTrim(device):
         pdevice = int(CUdevice(device))
     cydevice = <cydriver.CUdevice>pdevice
     err = cydriver.cuDeviceGraphMemTrim(cydevice)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceGetGraphMemAttribute' in found_functions}}
@@ -42035,7 +42363,7 @@ def cuDeviceGetGraphMemAttribute(device, attr not None : CUgraphMem_attribute):
     cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, 0, is_getter=True)
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     err = cydriver.cuDeviceGetGraphMemAttribute(cydevice, cyattr, cyvalue_ptr)
-    return (CUresult(err), cyvalue.pyObj())
+    return (_dict_CUresult[err], cyvalue.pyObj())
 {{endif}}
 
 {{if 'cuDeviceSetGraphMemAttribute' in found_functions}}
@@ -42084,7 +42412,7 @@ def cuDeviceSetGraphMemAttribute(device, attr not None : CUgraphMem_attribute, v
     cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, value, is_getter=False)
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     err = cydriver.cuDeviceSetGraphMemAttribute(cydevice, cyattr, cyvalue_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphClone' in found_functions}}
@@ -42127,7 +42455,7 @@ def cuGraphClone(originalGraph):
     cyoriginalGraph = <cydriver.CUgraph><void_ptr>poriginalGraph
     cdef CUgraph phGraphClone = CUgraph()
     err = cydriver.cuGraphClone(<cydriver.CUgraph*>phGraphClone._pvt_ptr, cyoriginalGraph)
-    return (CUresult(err), phGraphClone)
+    return (_dict_CUresult[err], phGraphClone)
 {{endif}}
 
 {{if 'cuGraphNodeFindInClone' in found_functions}}
@@ -42181,7 +42509,7 @@ def cuGraphNodeFindInClone(hOriginalNode, hClonedGraph):
     cyhOriginalNode = <cydriver.CUgraphNode><void_ptr>phOriginalNode
     cdef CUgraphNode phNode = CUgraphNode()
     err = cydriver.cuGraphNodeFindInClone(<cydriver.CUgraphNode*>phNode._pvt_ptr, cyhOriginalNode, cyhClonedGraph)
-    return (CUresult(err), phNode)
+    return (_dict_CUresult[err], phNode)
 {{endif}}
 
 {{if 'cuGraphNodeGetType' in found_functions}}
@@ -42218,7 +42546,7 @@ def cuGraphNodeGetType(hNode):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUgraphNodeType typename
     err = cydriver.cuGraphNodeGetType(cyhNode, &typename)
-    return (CUresult(err), CUgraphNodeType(typename))
+    return (_dict_CUresult[err], CUgraphNodeType(typename))
 {{endif}}
 
 {{if 'cuGraphGetNodes' in found_functions}}
@@ -42274,7 +42602,7 @@ def cuGraphGetNodes(hGraph, size_t numNodes = 0):
         pynodes = [CUgraphNode(init_value=<void_ptr>cynodes[idx]) for idx in range(_graph_length)]
     if cynodes is not NULL:
         free(cynodes)
-    return (CUresult(err), pynodes, numNodes)
+    return (_dict_CUresult[err], pynodes, numNodes)
 {{endif}}
 
 {{if 'cuGraphGetRootNodes' in found_functions}}
@@ -42330,7 +42658,7 @@ def cuGraphGetRootNodes(hGraph, size_t numRootNodes = 0):
         pyrootNodes = [CUgraphNode(init_value=<void_ptr>cyrootNodes[idx]) for idx in range(_graph_length)]
     if cyrootNodes is not NULL:
         free(cyrootNodes)
-    return (CUresult(err), pyrootNodes, numRootNodes)
+    return (_dict_CUresult[err], pyrootNodes, numRootNodes)
 {{endif}}
 
 {{if 'cuGraphGetEdges' in found_functions}}
@@ -42400,7 +42728,7 @@ def cuGraphGetEdges(hGraph, size_t numEdges = 0):
         pyto = [CUgraphNode(init_value=<void_ptr>cyto[idx]) for idx in range(_graph_length)]
     if cyto is not NULL:
         free(cyto)
-    return (CUresult(err), pyfrom_, pyto, numEdges)
+    return (_dict_CUresult[err], pyfrom_, pyto, numEdges)
 {{endif}}
 
 {{if 'cuGraphGetEdges_v2' in found_functions}}
@@ -42487,7 +42815,7 @@ def cuGraphGetEdges_v2(hGraph, size_t numEdges = 0):
         pyedgeData = [CUgraphEdgeData(_ptr=<void_ptr>&cyedgeData[idx]) for idx in range(_graph_length)]
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (CUresult(err), pyfrom_, pyto, pyedgeData, numEdges)
+    return (_dict_CUresult[err], pyfrom_, pyto, pyedgeData, numEdges)
 {{endif}}
 
 {{if 'cuGraphNodeGetDependencies' in found_functions}}
@@ -42544,7 +42872,7 @@ def cuGraphNodeGetDependencies(hNode, size_t numDependencies = 0):
         pydependencies = [CUgraphNode(init_value=<void_ptr>cydependencies[idx]) for idx in range(_graph_length)]
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), pydependencies, numDependencies)
+    return (_dict_CUresult[err], pydependencies, numDependencies)
 {{endif}}
 
 {{if 'cuGraphNodeGetDependencies_v2' in found_functions}}
@@ -42618,7 +42946,7 @@ def cuGraphNodeGetDependencies_v2(hNode, size_t numDependencies = 0):
         pyedgeData = [CUgraphEdgeData(_ptr=<void_ptr>&cyedgeData[idx]) for idx in range(_graph_length)]
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (CUresult(err), pydependencies, pyedgeData, numDependencies)
+    return (_dict_CUresult[err], pydependencies, pyedgeData, numDependencies)
 {{endif}}
 
 {{if 'cuGraphNodeGetDependentNodes' in found_functions}}
@@ -42675,7 +43003,7 @@ def cuGraphNodeGetDependentNodes(hNode, size_t numDependentNodes = 0):
         pydependentNodes = [CUgraphNode(init_value=<void_ptr>cydependentNodes[idx]) for idx in range(_graph_length)]
     if cydependentNodes is not NULL:
         free(cydependentNodes)
-    return (CUresult(err), pydependentNodes, numDependentNodes)
+    return (_dict_CUresult[err], pydependentNodes, numDependentNodes)
 {{endif}}
 
 {{if 'cuGraphNodeGetDependentNodes_v2' in found_functions}}
@@ -42749,7 +43077,7 @@ def cuGraphNodeGetDependentNodes_v2(hNode, size_t numDependentNodes = 0):
         pyedgeData = [CUgraphEdgeData(_ptr=<void_ptr>&cyedgeData[idx]) for idx in range(_graph_length)]
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (CUresult(err), pydependentNodes, pyedgeData, numDependentNodes)
+    return (_dict_CUresult[err], pydependentNodes, pyedgeData, numDependentNodes)
 {{endif}}
 
 {{if 'cuGraphAddDependencies' in found_functions}}
@@ -42820,7 +43148,7 @@ def cuGraphAddDependencies(hGraph, from_ : Optional[Tuple[CUgraphNode] | List[CU
         free(cyfrom_)
     if cyto is not NULL:
         free(cyto)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddDependencies_v2' in found_functions}}
@@ -42906,7 +43234,7 @@ def cuGraphAddDependencies_v2(hGraph, from_ : Optional[Tuple[CUgraphNode] | List
         free(cyto)
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphRemoveDependencies' in found_functions}}
@@ -42981,7 +43309,7 @@ def cuGraphRemoveDependencies(hGraph, from_ : Optional[Tuple[CUgraphNode] | List
         free(cyfrom_)
     if cyto is not NULL:
         free(cyto)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphRemoveDependencies_v2' in found_functions}}
@@ -43073,7 +43401,7 @@ def cuGraphRemoveDependencies_v2(hGraph, from_ : Optional[Tuple[CUgraphNode] | L
         free(cyto)
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphDestroyNode' in found_functions}}
@@ -43111,7 +43439,7 @@ def cuGraphDestroyNode(hNode):
         phNode = int(CUgraphNode(hNode))
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     err = cydriver.cuGraphDestroyNode(cyhNode)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphInstantiateWithFlags' in found_functions}}
@@ -43213,7 +43541,7 @@ def cuGraphInstantiate(hGraph, unsigned long long flags):
     cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphExec phGraphExec = CUgraphExec()
     err = cydriver.cuGraphInstantiate(<cydriver.CUgraphExec*>phGraphExec._pvt_ptr, cyhGraph, flags)
-    return (CUresult(err), phGraphExec)
+    return (_dict_CUresult[err], phGraphExec)
 {{endif}}
 
 {{if 'cuGraphInstantiateWithParams' in found_functions}}
@@ -43356,7 +43684,7 @@ def cuGraphInstantiateWithParams(hGraph, instantiateParams : Optional[CUDA_GRAPH
     cdef CUgraphExec phGraphExec = CUgraphExec()
     cdef cydriver.CUDA_GRAPH_INSTANTIATE_PARAMS* cyinstantiateParams_ptr = instantiateParams._pvt_ptr if instantiateParams != None else NULL
     err = cydriver.cuGraphInstantiateWithParams(<cydriver.CUgraphExec*>phGraphExec._pvt_ptr, cyhGraph, cyinstantiateParams_ptr)
-    return (CUresult(err), phGraphExec)
+    return (_dict_CUresult[err], phGraphExec)
 {{endif}}
 
 {{if 'cuGraphExecGetFlags' in found_functions}}
@@ -43396,7 +43724,7 @@ def cuGraphExecGetFlags(hGraphExec):
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cuuint64_t flags = cuuint64_t()
     err = cydriver.cuGraphExecGetFlags(cyhGraphExec, <cydriver.cuuint64_t*>flags._pvt_ptr)
-    return (CUresult(err), flags)
+    return (_dict_CUresult[err], flags)
 {{endif}}
 
 {{if 'cuGraphExecKernelNodeSetParams_v2' in found_functions}}
@@ -43476,7 +43804,7 @@ def cuGraphExecKernelNodeSetParams(hGraphExec, hNode, nodeParams : Optional[CUDA
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_KERNEL_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExecKernelNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecMemcpyNodeSetParams' in found_functions}}
@@ -43550,7 +43878,7 @@ def cuGraphExecMemcpyNodeSetParams(hGraphExec, hNode, copyParams : Optional[CUDA
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_MEMCPY3D* cycopyParams_ptr = copyParams._pvt_ptr if copyParams != None else NULL
     err = cydriver.cuGraphExecMemcpyNodeSetParams(cyhGraphExec, cyhNode, cycopyParams_ptr, cyctx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecMemsetNodeSetParams' in found_functions}}
@@ -43629,7 +43957,7 @@ def cuGraphExecMemsetNodeSetParams(hGraphExec, hNode, memsetParams : Optional[CU
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_MEMSET_NODE_PARAMS* cymemsetParams_ptr = memsetParams._pvt_ptr if memsetParams != None else NULL
     err = cydriver.cuGraphExecMemsetNodeSetParams(cyhGraphExec, cyhNode, cymemsetParams_ptr, cyctx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecHostNodeSetParams' in found_functions}}
@@ -43683,7 +44011,7 @@ def cuGraphExecHostNodeSetParams(hGraphExec, hNode, nodeParams : Optional[CUDA_H
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_HOST_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExecHostNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecChildGraphNodeSetParams' in found_functions}}
@@ -43752,7 +44080,7 @@ def cuGraphExecChildGraphNodeSetParams(hGraphExec, hNode, childGraph):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphExecChildGraphNodeSetParams(cyhGraphExec, cyhNode, cychildGraph)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecEventRecordNodeSetEvent' in found_functions}}
@@ -43814,7 +44142,7 @@ def cuGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphExecEventRecordNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecEventWaitNodeSetEvent' in found_functions}}
@@ -43876,7 +44204,7 @@ def cuGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphExecEventWaitNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
@@ -43935,7 +44263,7 @@ def cuGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodePara
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExecExternalSemaphoresSignalNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
@@ -43994,7 +44322,7 @@ def cuGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExecExternalSemaphoresWaitNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphNodeSetEnabled' in found_functions}}
@@ -44062,7 +44390,7 @@ def cuGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphNodeSetEnabled(cyhGraphExec, cyhNode, isEnabled)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphNodeGetEnabled' in found_functions}}
@@ -44120,7 +44448,7 @@ def cuGraphNodeGetEnabled(hGraphExec, hNode):
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef unsigned int isEnabled = 0
     err = cydriver.cuGraphNodeGetEnabled(cyhGraphExec, cyhNode, &isEnabled)
-    return (CUresult(err), isEnabled)
+    return (_dict_CUresult[err], isEnabled)
 {{endif}}
 
 {{if 'cuGraphUpload' in found_functions}}
@@ -44168,7 +44496,7 @@ def cuGraphUpload(hGraphExec, hStream):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphUpload(cyhGraphExec, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphLaunch' in found_functions}}
@@ -44221,7 +44549,7 @@ def cuGraphLaunch(hGraphExec, hStream):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphLaunch(cyhGraphExec, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecDestroy' in found_functions}}
@@ -44257,7 +44585,7 @@ def cuGraphExecDestroy(hGraphExec):
         phGraphExec = int(CUgraphExec(hGraphExec))
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     err = cydriver.cuGraphExecDestroy(cyhGraphExec)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphDestroy' in found_functions}}
@@ -44291,7 +44619,7 @@ def cuGraphDestroy(hGraph):
         phGraph = int(CUgraph(hGraph))
     cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     err = cydriver.cuGraphDestroy(cyhGraph)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecUpdate_v2' in found_functions}}
@@ -44468,7 +44796,7 @@ def cuGraphExecUpdate(hGraphExec, hGraph):
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef CUgraphExecUpdateResultInfo resultInfo = CUgraphExecUpdateResultInfo()
     err = cydriver.cuGraphExecUpdate(cyhGraphExec, cyhGraph, <cydriver.CUgraphExecUpdateResultInfo*>resultInfo._pvt_ptr)
-    return (CUresult(err), resultInfo)
+    return (_dict_CUresult[err], resultInfo)
 {{endif}}
 
 {{if 'cuGraphKernelNodeCopyAttributes' in found_functions}}
@@ -44514,7 +44842,7 @@ def cuGraphKernelNodeCopyAttributes(dst, src):
         pdst = int(CUgraphNode(dst))
     cydst = <cydriver.CUgraphNode><void_ptr>pdst
     err = cydriver.cuGraphKernelNodeCopyAttributes(cydst, cysrc)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphKernelNodeGetAttribute' in found_functions}}
@@ -44555,7 +44883,7 @@ def cuGraphKernelNodeGetAttribute(hNode, attr not None : CUkernelNodeAttrID):
     cdef cydriver.CUkernelNodeAttrID cyattr = attr.value
     cdef CUkernelNodeAttrValue value_out = CUkernelNodeAttrValue()
     err = cydriver.cuGraphKernelNodeGetAttribute(cyhNode, cyattr, <cydriver.CUkernelNodeAttrValue*>value_out._pvt_ptr)
-    return (CUresult(err), value_out)
+    return (_dict_CUresult[err], value_out)
 {{endif}}
 
 {{if 'cuGraphKernelNodeSetAttribute' in found_functions}}
@@ -44596,7 +44924,7 @@ def cuGraphKernelNodeSetAttribute(hNode, attr not None : CUkernelNodeAttrID, val
     cdef cydriver.CUkernelNodeAttrID cyattr = attr.value
     cdef cydriver.CUkernelNodeAttrValue* cyvalue_ptr = value._pvt_ptr if value != None else NULL
     err = cydriver.cuGraphKernelNodeSetAttribute(cyhNode, cyattr, cyvalue_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphDebugDotPrint' in found_functions}}
@@ -44635,7 +44963,7 @@ def cuGraphDebugDotPrint(hGraph, char* path, unsigned int flags):
         phGraph = int(CUgraph(hGraph))
     cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     err = cydriver.cuGraphDebugDotPrint(cyhGraph, path, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuUserObjectCreate' in found_functions}}
@@ -44694,7 +45022,7 @@ def cuUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned int
     cyptr = utils.HelperInputVoidPtr(ptr)
     cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     err = cydriver.cuUserObjectCreate(<cydriver.CUuserObject*>object_out._pvt_ptr, cyptr_ptr, cydestroy, initialRefcount, flags)
-    return (CUresult(err), object_out)
+    return (_dict_CUresult[err], object_out)
 {{endif}}
 
 {{if 'cuUserObjectRetain' in found_functions}}
@@ -44735,7 +45063,7 @@ def cuUserObjectRetain(object, unsigned int count):
         pobject = int(CUuserObject(object))
     cyobject = <cydriver.CUuserObject><void_ptr>pobject
     err = cydriver.cuUserObjectRetain(cyobject, count)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuUserObjectRelease' in found_functions}}
@@ -44779,7 +45107,7 @@ def cuUserObjectRelease(object, unsigned int count):
         pobject = int(CUuserObject(object))
     cyobject = <cydriver.CUuserObject><void_ptr>pobject
     err = cydriver.cuUserObjectRelease(cyobject, count)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphRetainUserObject' in found_functions}}
@@ -44834,7 +45162,7 @@ def cuGraphRetainUserObject(graph, object, unsigned int count, unsigned int flag
         pgraph = int(CUgraph(graph))
     cygraph = <cydriver.CUgraph><void_ptr>pgraph
     err = cydriver.cuGraphRetainUserObject(cygraph, cyobject, count, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphReleaseUserObject' in found_functions}}
@@ -44884,7 +45212,7 @@ def cuGraphReleaseUserObject(graph, object, unsigned int count):
         pgraph = int(CUgraph(graph))
     cygraph = <cydriver.CUgraph><void_ptr>pgraph
     err = cydriver.cuGraphReleaseUserObject(cygraph, cyobject, count)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphAddNode' in found_functions}}
@@ -44959,7 +45287,7 @@ def cuGraphAddNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUg
     err = cydriver.cuGraphAddNode(<cydriver.CUgraphNode*>phGraphNode._pvt_ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphAddNode_v2' in found_functions}}
@@ -45050,7 +45378,7 @@ def cuGraphAddNode_v2(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[
         free(cydependencies)
     if cydependencyData is not NULL:
         free(cydependencyData)
-    return (CUresult(err), phGraphNode)
+    return (_dict_CUresult[err], phGraphNode)
 {{endif}}
 
 {{if 'cuGraphNodeSetParams' in found_functions}}
@@ -45093,7 +45421,7 @@ def cuGraphNodeSetParams(hNode, nodeParams : Optional[CUgraphNodeParams]):
     cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef cydriver.CUgraphNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphExecNodeSetParams' in found_functions}}
@@ -45152,7 +45480,7 @@ def cuGraphExecNodeSetParams(hGraphExec, hNode, nodeParams : Optional[CUgraphNod
     cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef cydriver.CUgraphNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cydriver.cuGraphExecNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphConditionalHandleCreate' in found_functions}}
@@ -45214,7 +45542,7 @@ def cuGraphConditionalHandleCreate(hGraph, ctx, unsigned int defaultLaunchValue,
     cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphConditionalHandle pHandle_out = CUgraphConditionalHandle()
     err = cydriver.cuGraphConditionalHandleCreate(<cydriver.CUgraphConditionalHandle*>pHandle_out._pvt_ptr, cyhGraph, cyctx, defaultLaunchValue, flags)
-    return (CUresult(err), pHandle_out)
+    return (_dict_CUresult[err], pHandle_out)
 {{endif}}
 
 {{if 'cuOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}
@@ -45262,7 +45590,7 @@ def cuOccupancyMaxActiveBlocksPerMultiprocessor(func, int blockSize, size_t dyna
     cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int numBlocks = 0
     err = cydriver.cuOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, cyfunc, blockSize, dynamicSMemSize)
-    return (CUresult(err), numBlocks)
+    return (_dict_CUresult[err], numBlocks)
 {{endif}}
 
 {{if 'cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}
@@ -45328,7 +45656,7 @@ def cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(func, int blockSize, si
     cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int numBlocks = 0
     err = cydriver.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlocks, cyfunc, blockSize, dynamicSMemSize, flags)
-    return (CUresult(err), numBlocks)
+    return (_dict_CUresult[err], numBlocks)
 {{endif}}
 
 {{if 'cuOccupancyMaxPotentialBlockSize' in found_functions}}
@@ -45412,7 +45740,7 @@ def cuOccupancyMaxPotentialBlockSize(func, blockSizeToDynamicSMemSize, size_t dy
     cdef int minGridSize = 0
     cdef int blockSize = 0
     err = cydriver.cuOccupancyMaxPotentialBlockSize(&minGridSize, &blockSize, cyfunc, cyblockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
-    return (CUresult(err), minGridSize, blockSize)
+    return (_dict_CUresult[err], minGridSize, blockSize)
 {{endif}}
 
 {{if 'cuOccupancyMaxPotentialBlockSizeWithFlags' in found_functions}}
@@ -45495,7 +45823,7 @@ def cuOccupancyMaxPotentialBlockSizeWithFlags(func, blockSizeToDynamicSMemSize,
     cdef int minGridSize = 0
     cdef int blockSize = 0
     err = cydriver.cuOccupancyMaxPotentialBlockSizeWithFlags(&minGridSize, &blockSize, cyfunc, cyblockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
-    return (CUresult(err), minGridSize, blockSize)
+    return (_dict_CUresult[err], minGridSize, blockSize)
 {{endif}}
 
 {{if 'cuOccupancyAvailableDynamicSMemPerBlock' in found_functions}}
@@ -45539,7 +45867,7 @@ def cuOccupancyAvailableDynamicSMemPerBlock(func, int numBlocks, int blockSize):
     cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef size_t dynamicSmemSize = 0
     err = cydriver.cuOccupancyAvailableDynamicSMemPerBlock(&dynamicSmemSize, cyfunc, numBlocks, blockSize)
-    return (CUresult(err), dynamicSmemSize)
+    return (_dict_CUresult[err], dynamicSmemSize)
 {{endif}}
 
 {{if 'cuOccupancyMaxPotentialClusterSize' in found_functions}}
@@ -45596,7 +45924,7 @@ def cuOccupancyMaxPotentialClusterSize(func, config : Optional[CUlaunchConfig]):
     cdef int clusterSize = 0
     cdef cydriver.CUlaunchConfig* cyconfig_ptr = config._pvt_ptr if config != None else NULL
     err = cydriver.cuOccupancyMaxPotentialClusterSize(&clusterSize, cyfunc, cyconfig_ptr)
-    return (CUresult(err), clusterSize)
+    return (_dict_CUresult[err], clusterSize)
 {{endif}}
 
 {{if 'cuOccupancyMaxActiveClusters' in found_functions}}
@@ -45653,7 +45981,7 @@ def cuOccupancyMaxActiveClusters(func, config : Optional[CUlaunchConfig]):
     cdef int numClusters = 0
     cdef cydriver.CUlaunchConfig* cyconfig_ptr = config._pvt_ptr if config != None else NULL
     err = cydriver.cuOccupancyMaxActiveClusters(&numClusters, cyfunc, cyconfig_ptr)
-    return (CUresult(err), numClusters)
+    return (_dict_CUresult[err], numClusters)
 {{endif}}
 
 {{if 'cuTexRefSetArray' in found_functions}}
@@ -45705,7 +46033,7 @@ def cuTexRefSetArray(hTexRef, hArray, unsigned int Flags):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetArray(cyhTexRef, cyhArray, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetMipmappedArray' in found_functions}}
@@ -45757,7 +46085,7 @@ def cuTexRefSetMipmappedArray(hTexRef, hMipmappedArray, unsigned int Flags):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetMipmappedArray(cyhTexRef, cyhMipmappedArray, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetAddress_v2' in found_functions}}
@@ -45829,7 +46157,7 @@ def cuTexRefSetAddress(hTexRef, dptr, size_t numbytes):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef size_t ByteOffset = 0
     err = cydriver.cuTexRefSetAddress(&ByteOffset, cyhTexRef, cydptr, numbytes)
-    return (CUresult(err), ByteOffset)
+    return (_dict_CUresult[err], ByteOffset)
 {{endif}}
 
 {{if 'cuTexRefSetAddress2D_v3' in found_functions}}
@@ -45909,7 +46237,7 @@ def cuTexRefSetAddress2D(hTexRef, desc : Optional[CUDA_ARRAY_DESCRIPTOR], dptr,
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUDA_ARRAY_DESCRIPTOR* cydesc_ptr = desc._pvt_ptr if desc != None else NULL
     err = cydriver.cuTexRefSetAddress2D(cyhTexRef, cydesc_ptr, cydptr, Pitch)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetFormat' in found_functions}}
@@ -45954,7 +46282,7 @@ def cuTexRefSetFormat(hTexRef, fmt not None : CUarray_format, int NumPackedCompo
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUarray_format cyfmt = fmt.value
     err = cydriver.cuTexRefSetFormat(cyhTexRef, cyfmt, NumPackedComponents)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetAddressMode' in found_functions}}
@@ -46006,7 +46334,7 @@ def cuTexRefSetAddressMode(hTexRef, int dim, am not None : CUaddress_mode):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUaddress_mode cyam = am.value
     err = cydriver.cuTexRefSetAddressMode(cyhTexRef, dim, cyam)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetFilterMode' in found_functions}}
@@ -46052,7 +46380,7 @@ def cuTexRefSetFilterMode(hTexRef, fm not None : CUfilter_mode):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUfilter_mode cyfm = fm.value
     err = cydriver.cuTexRefSetFilterMode(cyhTexRef, cyfm)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetMipmapFilterMode' in found_functions}}
@@ -46098,7 +46426,7 @@ def cuTexRefSetMipmapFilterMode(hTexRef, fm not None : CUfilter_mode):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUfilter_mode cyfm = fm.value
     err = cydriver.cuTexRefSetMipmapFilterMode(cyhTexRef, cyfm)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetMipmapLevelBias' in found_functions}}
@@ -46141,7 +46469,7 @@ def cuTexRefSetMipmapLevelBias(hTexRef, float bias):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetMipmapLevelBias(cyhTexRef, bias)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetMipmapLevelClamp' in found_functions}}
@@ -46186,7 +46514,7 @@ def cuTexRefSetMipmapLevelClamp(hTexRef, float minMipmapLevelClamp, float maxMip
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetMipmapLevelClamp(cyhTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetMaxAnisotropy' in found_functions}}
@@ -46228,7 +46556,7 @@ def cuTexRefSetMaxAnisotropy(hTexRef, unsigned int maxAniso):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetMaxAnisotropy(cyhTexRef, maxAniso)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetBorderColor' in found_functions}}
@@ -46275,7 +46603,7 @@ def cuTexRefSetBorderColor(hTexRef, float pBorderColor):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetBorderColor(cyhTexRef, &pBorderColor)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefSetFlags' in found_functions}}
@@ -46332,7 +46660,7 @@ def cuTexRefSetFlags(hTexRef, unsigned int Flags):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefSetFlags(cyhTexRef, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexRefGetAddress_v2' in found_functions}}
@@ -46373,7 +46701,7 @@ def cuTexRefGetAddress(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef CUdeviceptr pdptr = CUdeviceptr()
     err = cydriver.cuTexRefGetAddress(<cydriver.CUdeviceptr*>pdptr._pvt_ptr, cyhTexRef)
-    return (CUresult(err), pdptr)
+    return (_dict_CUresult[err], pdptr)
 {{endif}}
 
 {{if 'cuTexRefGetArray' in found_functions}}
@@ -46414,7 +46742,7 @@ def cuTexRefGetArray(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef CUarray phArray = CUarray()
     err = cydriver.cuTexRefGetArray(<cydriver.CUarray*>phArray._pvt_ptr, cyhTexRef)
-    return (CUresult(err), phArray)
+    return (_dict_CUresult[err], phArray)
 {{endif}}
 
 {{if 'cuTexRefGetMipmappedArray' in found_functions}}
@@ -46456,7 +46784,7 @@ def cuTexRefGetMipmappedArray(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef CUmipmappedArray phMipmappedArray = CUmipmappedArray()
     err = cydriver.cuTexRefGetMipmappedArray(<cydriver.CUmipmappedArray*>phMipmappedArray._pvt_ptr, cyhTexRef)
-    return (CUresult(err), phMipmappedArray)
+    return (_dict_CUresult[err], phMipmappedArray)
 {{endif}}
 
 {{if 'cuTexRefGetAddressMode' in found_functions}}
@@ -46499,7 +46827,7 @@ def cuTexRefGetAddressMode(hTexRef, int dim):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUaddress_mode pam
     err = cydriver.cuTexRefGetAddressMode(&pam, cyhTexRef, dim)
-    return (CUresult(err), CUaddress_mode(pam))
+    return (_dict_CUresult[err], CUaddress_mode(pam))
 {{endif}}
 
 {{if 'cuTexRefGetFilterMode' in found_functions}}
@@ -46539,7 +46867,7 @@ def cuTexRefGetFilterMode(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUfilter_mode pfm
     err = cydriver.cuTexRefGetFilterMode(&pfm, cyhTexRef)
-    return (CUresult(err), CUfilter_mode(pfm))
+    return (_dict_CUresult[err], CUfilter_mode(pfm))
 {{endif}}
 
 {{if 'cuTexRefGetFormat' in found_functions}}
@@ -46583,7 +46911,7 @@ def cuTexRefGetFormat(hTexRef):
     cdef cydriver.CUarray_format pFormat
     cdef int pNumChannels = 0
     err = cydriver.cuTexRefGetFormat(&pFormat, &pNumChannels, cyhTexRef)
-    return (CUresult(err), CUarray_format(pFormat), pNumChannels)
+    return (_dict_CUresult[err], CUarray_format(pFormat), pNumChannels)
 {{endif}}
 
 {{if 'cuTexRefGetMipmapFilterMode' in found_functions}}
@@ -46623,7 +46951,7 @@ def cuTexRefGetMipmapFilterMode(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef cydriver.CUfilter_mode pfm
     err = cydriver.cuTexRefGetMipmapFilterMode(&pfm, cyhTexRef)
-    return (CUresult(err), CUfilter_mode(pfm))
+    return (_dict_CUresult[err], CUfilter_mode(pfm))
 {{endif}}
 
 {{if 'cuTexRefGetMipmapLevelBias' in found_functions}}
@@ -46664,7 +46992,7 @@ def cuTexRefGetMipmapLevelBias(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef float pbias = 0
     err = cydriver.cuTexRefGetMipmapLevelBias(&pbias, cyhTexRef)
-    return (CUresult(err), pbias)
+    return (_dict_CUresult[err], pbias)
 {{endif}}
 
 {{if 'cuTexRefGetMipmapLevelClamp' in found_functions}}
@@ -46708,7 +47036,7 @@ def cuTexRefGetMipmapLevelClamp(hTexRef):
     cdef float pminMipmapLevelClamp = 0
     cdef float pmaxMipmapLevelClamp = 0
     err = cydriver.cuTexRefGetMipmapLevelClamp(&pminMipmapLevelClamp, &pmaxMipmapLevelClamp, cyhTexRef)
-    return (CUresult(err), pminMipmapLevelClamp, pmaxMipmapLevelClamp)
+    return (_dict_CUresult[err], pminMipmapLevelClamp, pmaxMipmapLevelClamp)
 {{endif}}
 
 {{if 'cuTexRefGetMaxAnisotropy' in found_functions}}
@@ -46748,7 +47076,7 @@ def cuTexRefGetMaxAnisotropy(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef int pmaxAniso = 0
     err = cydriver.cuTexRefGetMaxAnisotropy(&pmaxAniso, cyhTexRef)
-    return (CUresult(err), pmaxAniso)
+    return (_dict_CUresult[err], pmaxAniso)
 {{endif}}
 
 {{if 'cuTexRefGetBorderColor' in found_functions}}
@@ -46791,7 +47119,7 @@ def cuTexRefGetBorderColor(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef float pBorderColor = 0
     err = cydriver.cuTexRefGetBorderColor(&pBorderColor, cyhTexRef)
-    return (CUresult(err), pBorderColor)
+    return (_dict_CUresult[err], pBorderColor)
 {{endif}}
 
 {{if 'cuTexRefGetFlags' in found_functions}}
@@ -46830,7 +47158,7 @@ def cuTexRefGetFlags(hTexRef):
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef unsigned int pFlags = 0
     err = cydriver.cuTexRefGetFlags(&pFlags, cyhTexRef)
-    return (CUresult(err), pFlags)
+    return (_dict_CUresult[err], pFlags)
 {{endif}}
 
 {{if 'cuTexRefCreate' in found_functions}}
@@ -46861,7 +47189,7 @@ def cuTexRefCreate():
     """
     cdef CUtexref pTexRef = CUtexref()
     err = cydriver.cuTexRefCreate(<cydriver.CUtexref*>pTexRef._pvt_ptr)
-    return (CUresult(err), pTexRef)
+    return (_dict_CUresult[err], pTexRef)
 {{endif}}
 
 {{if 'cuTexRefDestroy' in found_functions}}
@@ -46897,7 +47225,7 @@ def cuTexRefDestroy(hTexRef):
         phTexRef = int(CUtexref(hTexRef))
     cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     err = cydriver.cuTexRefDestroy(cyhTexRef)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuSurfRefSetArray' in found_functions}}
@@ -46950,7 +47278,7 @@ def cuSurfRefSetArray(hSurfRef, hArray, unsigned int Flags):
         phSurfRef = int(CUsurfref(hSurfRef))
     cyhSurfRef = <cydriver.CUsurfref><void_ptr>phSurfRef
     err = cydriver.cuSurfRefSetArray(cyhSurfRef, cyhArray, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuSurfRefGetArray' in found_functions}}
@@ -46991,7 +47319,7 @@ def cuSurfRefGetArray(hSurfRef):
     cyhSurfRef = <cydriver.CUsurfref><void_ptr>phSurfRef
     cdef CUarray phArray = CUarray()
     err = cydriver.cuSurfRefGetArray(<cydriver.CUarray*>phArray._pvt_ptr, cyhSurfRef)
-    return (CUresult(err), phArray)
+    return (_dict_CUresult[err], phArray)
 {{endif}}
 
 {{if 'cuTexObjectCreate' in found_functions}}
@@ -47228,7 +47556,7 @@ def cuTexObjectCreate(pResDesc : Optional[CUDA_RESOURCE_DESC], pTexDesc : Option
     cdef cydriver.CUDA_TEXTURE_DESC* cypTexDesc_ptr = pTexDesc._pvt_ptr if pTexDesc != None else NULL
     cdef cydriver.CUDA_RESOURCE_VIEW_DESC* cypResViewDesc_ptr = pResViewDesc._pvt_ptr if pResViewDesc != None else NULL
     err = cydriver.cuTexObjectCreate(<cydriver.CUtexObject*>pTexObject._pvt_ptr, cypResDesc_ptr, cypTexDesc_ptr, cypResViewDesc_ptr)
-    return (CUresult(err), pTexObject)
+    return (_dict_CUresult[err], pTexObject)
 {{endif}}
 
 {{if 'cuTexObjectDestroy' in found_functions}}
@@ -47262,7 +47590,7 @@ def cuTexObjectDestroy(texObject):
         ptexObject = int(CUtexObject(texObject))
     cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     err = cydriver.cuTexObjectDestroy(cytexObject)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuTexObjectGetResourceDesc' in found_functions}}
@@ -47300,7 +47628,7 @@ def cuTexObjectGetResourceDesc(texObject):
     cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     cdef CUDA_RESOURCE_DESC pResDesc = CUDA_RESOURCE_DESC()
     err = cydriver.cuTexObjectGetResourceDesc(<cydriver.CUDA_RESOURCE_DESC*>pResDesc._pvt_ptr, cytexObject)
-    return (CUresult(err), pResDesc)
+    return (_dict_CUresult[err], pResDesc)
 {{endif}}
 
 {{if 'cuTexObjectGetTextureDesc' in found_functions}}
@@ -47338,7 +47666,7 @@ def cuTexObjectGetTextureDesc(texObject):
     cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     cdef CUDA_TEXTURE_DESC pTexDesc = CUDA_TEXTURE_DESC()
     err = cydriver.cuTexObjectGetTextureDesc(<cydriver.CUDA_TEXTURE_DESC*>pTexDesc._pvt_ptr, cytexObject)
-    return (CUresult(err), pTexDesc)
+    return (_dict_CUresult[err], pTexDesc)
 {{endif}}
 
 {{if 'cuTexObjectGetResourceViewDesc' in found_functions}}
@@ -47377,7 +47705,7 @@ def cuTexObjectGetResourceViewDesc(texObject):
     cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     cdef CUDA_RESOURCE_VIEW_DESC pResViewDesc = CUDA_RESOURCE_VIEW_DESC()
     err = cydriver.cuTexObjectGetResourceViewDesc(<cydriver.CUDA_RESOURCE_VIEW_DESC*>pResViewDesc._pvt_ptr, cytexObject)
-    return (CUresult(err), pResViewDesc)
+    return (_dict_CUresult[err], pResViewDesc)
 {{endif}}
 
 {{if 'cuSurfObjectCreate' in found_functions}}
@@ -47417,7 +47745,7 @@ def cuSurfObjectCreate(pResDesc : Optional[CUDA_RESOURCE_DESC]):
     cdef CUsurfObject pSurfObject = CUsurfObject()
     cdef cydriver.CUDA_RESOURCE_DESC* cypResDesc_ptr = pResDesc._pvt_ptr if pResDesc != None else NULL
     err = cydriver.cuSurfObjectCreate(<cydriver.CUsurfObject*>pSurfObject._pvt_ptr, cypResDesc_ptr)
-    return (CUresult(err), pSurfObject)
+    return (_dict_CUresult[err], pSurfObject)
 {{endif}}
 
 {{if 'cuSurfObjectDestroy' in found_functions}}
@@ -47451,7 +47779,7 @@ def cuSurfObjectDestroy(surfObject):
         psurfObject = int(CUsurfObject(surfObject))
     cysurfObject = <cydriver.CUsurfObject><void_ptr>psurfObject
     err = cydriver.cuSurfObjectDestroy(cysurfObject)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuSurfObjectGetResourceDesc' in found_functions}}
@@ -47489,7 +47817,7 @@ def cuSurfObjectGetResourceDesc(surfObject):
     cysurfObject = <cydriver.CUsurfObject><void_ptr>psurfObject
     cdef CUDA_RESOURCE_DESC pResDesc = CUDA_RESOURCE_DESC()
     err = cydriver.cuSurfObjectGetResourceDesc(<cydriver.CUDA_RESOURCE_DESC*>pResDesc._pvt_ptr, cysurfObject)
-    return (CUresult(err), pResDesc)
+    return (_dict_CUresult[err], pResDesc)
 {{endif}}
 
 {{if 'cuTensorMapEncodeTiled' in found_functions}}
@@ -47789,7 +48117,7 @@ def cuTensorMapEncodeTiled(tensorDataType not None : CUtensorMapDataType, tensor
         free(cyboxDim)
     if cyelementStrides is not NULL:
         free(cyelementStrides)
-    return (CUresult(err), tensorMap)
+    return (_dict_CUresult[err], tensorMap)
 {{endif}}
 
 {{if 'cuTensorMapEncodeIm2col' in found_functions}}
@@ -48127,7 +48455,7 @@ def cuTensorMapEncodeIm2col(tensorDataType not None : CUtensorMapDataType, tenso
         free(cyglobalStrides)
     if cyelementStrides is not NULL:
         free(cyelementStrides)
-    return (CUresult(err), tensorMap)
+    return (_dict_CUresult[err], tensorMap)
 {{endif}}
 
 {{if 'cuTensorMapEncodeIm2colWide' in found_functions}}
@@ -48445,7 +48773,7 @@ def cuTensorMapEncodeIm2colWide(tensorDataType not None : CUtensorMapDataType, t
         free(cyglobalStrides)
     if cyelementStrides is not NULL:
         free(cyelementStrides)
-    return (CUresult(err), tensorMap)
+    return (_dict_CUresult[err], tensorMap)
 {{endif}}
 
 {{if 'cuTensorMapReplaceAddress' in found_functions}}
@@ -48482,7 +48810,7 @@ def cuTensorMapReplaceAddress(tensorMap : Optional[CUtensorMap], globalAddress):
     cyglobalAddress = utils.HelperInputVoidPtr(globalAddress)
     cdef void* cyglobalAddress_ptr = <void*><void_ptr>cyglobalAddress.cptr
     err = cydriver.cuTensorMapReplaceAddress(cytensorMap_ptr, cyglobalAddress_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceCanAccessPeer' in found_functions}}
@@ -48535,7 +48863,7 @@ def cuDeviceCanAccessPeer(dev, peerDev):
     cydev = <cydriver.CUdevice>pdev
     cdef int canAccessPeer = 0
     err = cydriver.cuDeviceCanAccessPeer(&canAccessPeer, cydev, cypeerDev)
-    return (CUresult(err), canAccessPeer)
+    return (_dict_CUresult[err], canAccessPeer)
 {{endif}}
 
 {{if 'cuCtxEnablePeerAccess' in found_functions}}
@@ -48604,7 +48932,7 @@ def cuCtxEnablePeerAccess(peerContext, unsigned int Flags):
         ppeerContext = int(CUcontext(peerContext))
     cypeerContext = <cydriver.CUcontext><void_ptr>ppeerContext
     err = cydriver.cuCtxEnablePeerAccess(cypeerContext, Flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxDisablePeerAccess' in found_functions}}
@@ -48643,7 +48971,7 @@ def cuCtxDisablePeerAccess(peerContext):
         ppeerContext = int(CUcontext(peerContext))
     cypeerContext = <cydriver.CUcontext><void_ptr>ppeerContext
     err = cydriver.cuCtxDisablePeerAccess(cypeerContext)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuDeviceGetP2PAttribute' in found_functions}}
@@ -48714,7 +49042,7 @@ def cuDeviceGetP2PAttribute(attrib not None : CUdevice_P2PAttribute, srcDevice,
     cdef int value = 0
     cdef cydriver.CUdevice_P2PAttribute cyattrib = attrib.value
     err = cydriver.cuDeviceGetP2PAttribute(&value, cyattrib, cysrcDevice, cydstDevice)
-    return (CUresult(err), value)
+    return (_dict_CUresult[err], value)
 {{endif}}
 
 {{if 'cuGraphicsUnregisterResource' in found_functions}}
@@ -48752,7 +49080,7 @@ def cuGraphicsUnregisterResource(resource):
         presource = int(CUgraphicsResource(resource))
     cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     err = cydriver.cuGraphicsUnregisterResource(cyresource)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphicsSubResourceGetMappedArray' in found_functions}}
@@ -48807,7 +49135,7 @@ def cuGraphicsSubResourceGetMappedArray(resource, unsigned int arrayIndex, unsig
     cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUarray pArray = CUarray()
     err = cydriver.cuGraphicsSubResourceGetMappedArray(<cydriver.CUarray*>pArray._pvt_ptr, cyresource, arrayIndex, mipLevel)
-    return (CUresult(err), pArray)
+    return (_dict_CUresult[err], pArray)
 {{endif}}
 
 {{if 'cuGraphicsResourceGetMappedMipmappedArray' in found_functions}}
@@ -48851,7 +49179,7 @@ def cuGraphicsResourceGetMappedMipmappedArray(resource):
     cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUmipmappedArray pMipmappedArray = CUmipmappedArray()
     err = cydriver.cuGraphicsResourceGetMappedMipmappedArray(<cydriver.CUmipmappedArray*>pMipmappedArray._pvt_ptr, cyresource)
-    return (CUresult(err), pMipmappedArray)
+    return (_dict_CUresult[err], pMipmappedArray)
 {{endif}}
 
 {{if 'cuGraphicsResourceGetMappedPointer_v2' in found_functions}}
@@ -48895,7 +49223,7 @@ def cuGraphicsResourceGetMappedPointer(resource):
     cdef CUdeviceptr pDevPtr = CUdeviceptr()
     cdef size_t pSize = 0
     err = cydriver.cuGraphicsResourceGetMappedPointer(<cydriver.CUdeviceptr*>pDevPtr._pvt_ptr, &pSize, cyresource)
-    return (CUresult(err), pDevPtr, pSize)
+    return (_dict_CUresult[err], pDevPtr, pSize)
 {{endif}}
 
 {{if 'cuGraphicsResourceSetMapFlags_v2' in found_functions}}
@@ -48953,7 +49281,7 @@ def cuGraphicsResourceSetMapFlags(resource, unsigned int flags):
         presource = int(CUgraphicsResource(resource))
     cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     err = cydriver.cuGraphicsResourceSetMapFlags(cyresource, flags)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphicsMapResources' in found_functions}}
@@ -49015,7 +49343,7 @@ def cuGraphicsMapResources(unsigned int count, resources, hStream):
     else:
         raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, driver.CUgraphicsResource'>, found " + str(type(resources)))
     err = cydriver.cuGraphicsMapResources(count, cyresources, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGraphicsUnmapResources' in found_functions}}
@@ -49075,7 +49403,7 @@ def cuGraphicsUnmapResources(unsigned int count, resources, hStream):
     else:
         raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, driver.CUgraphicsResource'>, found " + str(type(resources)))
     err = cydriver.cuGraphicsUnmapResources(count, cyresources, cyhStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGetProcAddress_v2' in found_functions}}
@@ -49176,7 +49504,7 @@ def cuGetProcAddress(char* symbol, int cudaVersion, flags):
     cdef void_ptr pfn = 0
     cdef cydriver.CUdriverProcAddressQueryResult symbolStatus
     err = cydriver.cuGetProcAddress(symbol, <void**>&pfn, cudaVersion, cyflags, &symbolStatus)
-    return (CUresult(err), pfn, CUdriverProcAddressQueryResult(symbolStatus))
+    return (_dict_CUresult[err], pfn, CUdriverProcAddressQueryResult(symbolStatus))
 {{endif}}
 
 {{if 'cuCoredumpGetAttribute' in found_functions}}
@@ -49293,7 +49621,7 @@ def cuCoredumpGetAttribute(attrib not None : CUcoredumpSettings):
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     cdef size_t size = cyvalue.size()
     err = cydriver.cuCoredumpGetAttribute(cyattrib, cyvalue_ptr, &size)
-    return (CUresult(err), cyvalue.pyObj())
+    return (_dict_CUresult[err], cyvalue.pyObj())
 {{endif}}
 
 {{if 'cuCoredumpGetAttributeGlobal' in found_functions}}
@@ -49406,7 +49734,7 @@ def cuCoredumpGetAttributeGlobal(attrib not None : CUcoredumpSettings):
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     cdef size_t size = cyvalue.size()
     err = cydriver.cuCoredumpGetAttributeGlobal(cyattrib, cyvalue_ptr, &size)
-    return (CUresult(err), cyvalue.pyObj())
+    return (_dict_CUresult[err], cyvalue.pyObj())
 {{endif}}
 
 {{if 'cuCoredumpSetAttribute' in found_functions}}
@@ -49526,7 +49854,7 @@ def cuCoredumpSetAttribute(attrib not None : CUcoredumpSettings, value):
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     cdef size_t size = cyvalue.size()
     err = cydriver.cuCoredumpSetAttribute(cyattrib, cyvalue_ptr, &size)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCoredumpSetAttributeGlobal' in found_functions}}
@@ -49651,7 +49979,7 @@ def cuCoredumpSetAttributeGlobal(attrib not None : CUcoredumpSettings, value):
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     cdef size_t size = cyvalue.size()
     err = cydriver.cuCoredumpSetAttributeGlobal(cyattrib, cyvalue_ptr, &size)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGetExportTable' in found_functions}}
@@ -49675,7 +50003,7 @@ def cuGetExportTable(pExportTableId : Optional[CUuuid]):
     cdef void_ptr ppExportTable = 0
     cdef cydriver.CUuuid* cypExportTableId_ptr = pExportTableId._pvt_ptr if pExportTableId != None else NULL
     err = cydriver.cuGetExportTable(<const void**>&ppExportTable, cypExportTableId_ptr)
-    return (CUresult(err), ppExportTable)
+    return (_dict_CUresult[err], ppExportTable)
 {{endif}}
 
 {{if 'cuGreenCtxCreate' in found_functions}}
@@ -49748,7 +50076,7 @@ def cuGreenCtxCreate(desc, dev, unsigned int flags):
     cydesc = <cydriver.CUdevResourceDesc><void_ptr>pdesc
     cdef CUgreenCtx phCtx = CUgreenCtx()
     err = cydriver.cuGreenCtxCreate(<cydriver.CUgreenCtx*>phCtx._pvt_ptr, cydesc, cydev, flags)
-    return (CUresult(err), phCtx)
+    return (_dict_CUresult[err], phCtx)
 {{endif}}
 
 {{if 'cuGreenCtxDestroy' in found_functions}}
@@ -49785,7 +50113,7 @@ def cuGreenCtxDestroy(hCtx):
         phCtx = int(CUgreenCtx(hCtx))
     cyhCtx = <cydriver.CUgreenCtx><void_ptr>phCtx
     err = cydriver.cuGreenCtxDestroy(cyhCtx)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCtxFromGreenCtx' in found_functions}}
@@ -49831,7 +50159,7 @@ def cuCtxFromGreenCtx(hCtx):
     cyhCtx = <cydriver.CUgreenCtx><void_ptr>phCtx
     cdef CUcontext pContext = CUcontext()
     err = cydriver.cuCtxFromGreenCtx(<cydriver.CUcontext*>pContext._pvt_ptr, cyhCtx)
-    return (CUresult(err), pContext)
+    return (_dict_CUresult[err], pContext)
 {{endif}}
 
 {{if 'cuDeviceGetDevResource' in found_functions}}
@@ -49875,7 +50203,7 @@ def cuDeviceGetDevResource(device, typename not None : CUdevResourceType):
     cdef CUdevResource resource = CUdevResource()
     cdef cydriver.CUdevResourceType cytypename = typename.value
     err = cydriver.cuDeviceGetDevResource(cydevice, <cydriver.CUdevResource*>resource._pvt_ptr, cytypename)
-    return (CUresult(err), resource)
+    return (_dict_CUresult[err], resource)
 {{endif}}
 
 {{if 'cuCtxGetDevResource' in found_functions}}
@@ -49916,7 +50244,7 @@ def cuCtxGetDevResource(hCtx, typename not None : CUdevResourceType):
     cdef CUdevResource resource = CUdevResource()
     cdef cydriver.CUdevResourceType cytypename = typename.value
     err = cydriver.cuCtxGetDevResource(cyhCtx, <cydriver.CUdevResource*>resource._pvt_ptr, cytypename)
-    return (CUresult(err), resource)
+    return (_dict_CUresult[err], resource)
 {{endif}}
 
 {{if 'cuGreenCtxGetDevResource' in found_functions}}
@@ -49957,7 +50285,7 @@ def cuGreenCtxGetDevResource(hCtx, typename not None : CUdevResourceType):
     cdef CUdevResource resource = CUdevResource()
     cdef cydriver.CUdevResourceType cytypename = typename.value
     err = cydriver.cuGreenCtxGetDevResource(cyhCtx, <cydriver.CUdevResource*>resource._pvt_ptr, cytypename)
-    return (CUresult(err), resource)
+    return (_dict_CUresult[err], resource)
 {{endif}}
 
 {{if 'cuDevSmResourceSplitByCount' in found_functions}}
@@ -50072,7 +50400,7 @@ def cuDevSmResourceSplitByCount(unsigned int nbGroups, input_ : Optional[CUdevRe
             string.memcpy((<CUdevResource>pyresult[idx])._pvt_ptr, &cyresult[idx], sizeof(cydriver.CUdevResource))
     if cyresult is not NULL:
         free(cyresult)
-    return (CUresult(err), pyresult, cynbGroups, remaining)
+    return (_dict_CUresult[err], pyresult, cynbGroups, remaining)
 {{endif}}
 
 {{if 'cuDevResourceGenerateDesc' in found_functions}}
@@ -50134,7 +50462,7 @@ def cuDevResourceGenerateDesc(resources : Optional[Tuple[CUdevResource] | List[C
     err = cydriver.cuDevResourceGenerateDesc(<cydriver.CUdevResourceDesc*>phDesc._pvt_ptr, (<CUdevResource>resources[0])._pvt_ptr if len(resources) == 1 else cyresources, nbResources)
     if cyresources is not NULL:
         free(cyresources)
-    return (CUresult(err), phDesc)
+    return (_dict_CUresult[err], phDesc)
 {{endif}}
 
 {{if 'cuGreenCtxRecordEvent' in found_functions}}
@@ -50188,7 +50516,7 @@ def cuGreenCtxRecordEvent(hCtx, hEvent):
         phCtx = int(CUgreenCtx(hCtx))
     cyhCtx = <cydriver.CUgreenCtx><void_ptr>phCtx
     err = cydriver.cuGreenCtxRecordEvent(cyhCtx, cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuGreenCtxWaitEvent' in found_functions}}
@@ -50242,7 +50570,7 @@ def cuGreenCtxWaitEvent(hCtx, hEvent):
         phCtx = int(CUgreenCtx(hCtx))
     cyhCtx = <cydriver.CUgreenCtx><void_ptr>phCtx
     err = cydriver.cuGreenCtxWaitEvent(cyhCtx, cyhEvent)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuStreamGetGreenCtx' in found_functions}}
@@ -50299,7 +50627,7 @@ def cuStreamGetGreenCtx(hStream):
     cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUgreenCtx phCtx = CUgreenCtx()
     err = cydriver.cuStreamGetGreenCtx(cyhStream, <cydriver.CUgreenCtx*>phCtx._pvt_ptr)
-    return (CUresult(err), phCtx)
+    return (_dict_CUresult[err], phCtx)
 {{endif}}
 
 {{if 'cuGreenCtxStreamCreate' in found_functions}}
@@ -50371,7 +50699,7 @@ def cuGreenCtxStreamCreate(greenCtx, unsigned int flags, int priority):
     cygreenCtx = <cydriver.CUgreenCtx><void_ptr>pgreenCtx
     cdef CUstream phStream = CUstream()
     err = cydriver.cuGreenCtxStreamCreate(<cydriver.CUstream*>phStream._pvt_ptr, cygreenCtx, flags, priority)
-    return (CUresult(err), phStream)
+    return (_dict_CUresult[err], phStream)
 {{endif}}
 
 {{if 'cuCheckpointProcessGetRestoreThreadId' in found_functions}}
@@ -50397,7 +50725,7 @@ def cuCheckpointProcessGetRestoreThreadId(int pid):
     """
     cdef int tid = 0
     err = cydriver.cuCheckpointProcessGetRestoreThreadId(pid, &tid)
-    return (CUresult(err), tid)
+    return (_dict_CUresult[err], tid)
 {{endif}}
 
 {{if 'cuCheckpointProcessGetState' in found_functions}}
@@ -50423,7 +50751,7 @@ def cuCheckpointProcessGetState(int pid):
     """
     cdef cydriver.CUprocessState state
     err = cydriver.cuCheckpointProcessGetState(pid, &state)
-    return (CUresult(err), CUprocessState(state))
+    return (_dict_CUresult[err], CUprocessState(state))
 {{endif}}
 
 {{if 'cuCheckpointProcessLock' in found_functions}}
@@ -50454,7 +50782,7 @@ def cuCheckpointProcessLock(int pid, args : Optional[CUcheckpointLockArgs]):
     """
     cdef cydriver.CUcheckpointLockArgs* cyargs_ptr = args._pvt_ptr if args != None else NULL
     err = cydriver.cuCheckpointProcessLock(pid, cyargs_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCheckpointProcessCheckpoint' in found_functions}}
@@ -50484,7 +50812,7 @@ def cuCheckpointProcessCheckpoint(int pid, args : Optional[CUcheckpointCheckpoin
     """
     cdef cydriver.CUcheckpointCheckpointArgs* cyargs_ptr = args._pvt_ptr if args != None else NULL
     err = cydriver.cuCheckpointProcessCheckpoint(pid, cyargs_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCheckpointProcessRestore' in found_functions}}
@@ -50519,7 +50847,7 @@ def cuCheckpointProcessRestore(int pid, args : Optional[CUcheckpointRestoreArgs]
     """
     cdef cydriver.CUcheckpointRestoreArgs* cyargs_ptr = args._pvt_ptr if args != None else NULL
     err = cydriver.cuCheckpointProcessRestore(pid, cyargs_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuCheckpointProcessUnlock' in found_functions}}
@@ -50547,7 +50875,7 @@ def cuCheckpointProcessUnlock(int pid, args : Optional[CUcheckpointUnlockArgs]):
     """
     cdef cydriver.CUcheckpointUnlockArgs* cyargs_ptr = args._pvt_ptr if args != None else NULL
     err = cydriver.cuCheckpointProcessUnlock(pid, cyargs_ptr)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuProfilerStart' in found_functions}}
@@ -50574,7 +50902,7 @@ def cuProfilerStart():
     :py:obj:`~.cuProfilerInitialize`, :py:obj:`~.cuProfilerStop`, :py:obj:`~.cudaProfilerStart`
     """
     err = cydriver.cuProfilerStart()
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if 'cuProfilerStop' in found_functions}}
@@ -50601,7 +50929,7 @@ def cuProfilerStop():
     :py:obj:`~.cuProfilerInitialize`, :py:obj:`~.cuProfilerStart`, :py:obj:`~.cudaProfilerStop`
     """
     err = cydriver.cuProfilerStop()
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -50674,7 +51002,7 @@ def cuGraphicsEGLRegisterImage(image, unsigned int flags):
     cyimage = <cydriver.EGLImageKHR><void_ptr>pimage
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
     err = cydriver.cuGraphicsEGLRegisterImage(<cydriver.CUgraphicsResource*>pCudaResource._pvt_ptr, cyimage, flags)
-    return (CUresult(err), pCudaResource)
+    return (_dict_CUresult[err], pCudaResource)
 {{endif}}
 
 {{if True}}
@@ -50714,7 +51042,7 @@ def cuEGLStreamConsumerConnect(stream):
     cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     cdef CUeglStreamConnection conn = CUeglStreamConnection()
     err = cydriver.cuEGLStreamConsumerConnect(<cydriver.CUeglStreamConnection*>conn._pvt_ptr, cystream)
-    return (CUresult(err), conn)
+    return (_dict_CUresult[err], conn)
 {{endif}}
 
 {{if True}}
@@ -50758,7 +51086,7 @@ def cuEGLStreamConsumerConnectWithFlags(stream, unsigned int flags):
     cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     cdef CUeglStreamConnection conn = CUeglStreamConnection()
     err = cydriver.cuEGLStreamConsumerConnectWithFlags(<cydriver.CUeglStreamConnection*>conn._pvt_ptr, cystream, flags)
-    return (CUresult(err), conn)
+    return (_dict_CUresult[err], conn)
 {{endif}}
 
 {{if True}}
@@ -50794,7 +51122,7 @@ def cuEGLStreamConsumerDisconnect(conn):
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
     err = cydriver.cuEGLStreamConsumerDisconnect(cyconn)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -50865,7 +51193,7 @@ def cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int t
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
     err = cydriver.cuEGLStreamConsumerAcquireFrame(cyconn, cypCudaResource, cypStream, timeout)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -50927,7 +51255,7 @@ def cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream):
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
     err = cydriver.cuEGLStreamConsumerReleaseFrame(cyconn, cypCudaResource, cypStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -50987,7 +51315,7 @@ def cuEGLStreamProducerConnect(stream, width, height):
     cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     cdef CUeglStreamConnection conn = CUeglStreamConnection()
     err = cydriver.cuEGLStreamProducerConnect(<cydriver.CUeglStreamConnection*>conn._pvt_ptr, cystream, cywidth, cyheight)
-    return (CUresult(err), conn)
+    return (_dict_CUresult[err], conn)
 {{endif}}
 
 {{if True}}
@@ -51023,7 +51351,7 @@ def cuEGLStreamProducerDisconnect(conn):
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
     err = cydriver.cuEGLStreamProducerDisconnect(cyconn)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -51092,7 +51420,7 @@ def cuEGLStreamProducerPresentFrame(conn, eglframe not None : CUeglFrame, pStrea
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
     err = cydriver.cuEGLStreamProducerPresentFrame(cyconn, eglframe._pvt_ptr[0], cypStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -51146,7 +51474,7 @@ def cuEGLStreamProducerReturnFrame(conn, eglframe : Optional[CUeglFrame], pStrea
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
     cdef cydriver.CUeglFrame* cyeglframe_ptr = eglframe._pvt_ptr if eglframe != None else NULL
     err = cydriver.cuEGLStreamProducerReturnFrame(cyconn, cyeglframe_ptr, cypStream)
-    return (CUresult(err),)
+    return (_dict_CUresult[err],)
 {{endif}}
 
 {{if True}}
@@ -51192,7 +51520,7 @@ def cuGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned i
     cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUeglFrame eglFrame = CUeglFrame()
     err = cydriver.cuGraphicsResourceGetMappedEglFrame(<cydriver.CUeglFrame*>eglFrame._pvt_ptr, cyresource, index, mipLevel)
-    return (CUresult(err), eglFrame)
+    return (_dict_CUresult[err], eglFrame)
 {{endif}}
 
 {{if True}}
@@ -51248,7 +51576,7 @@ def cuEventCreateFromEGLSync(eglSync, unsigned int flags):
     cyeglSync = <cydriver.EGLSyncKHR><void_ptr>peglSync
     cdef CUevent phEvent = CUevent()
     err = cydriver.cuEventCreateFromEGLSync(<cydriver.CUevent*>phEvent._pvt_ptr, cyeglSync, flags)
-    return (CUresult(err), phEvent)
+    return (_dict_CUresult[err], phEvent)
 {{endif}}
 
 {{if True}}
@@ -51302,7 +51630,7 @@ def cuGraphicsGLRegisterBuffer(buffer, unsigned int Flags):
     cybuffer = <cydriver.GLuint><void_ptr>pbuffer
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
     err = cydriver.cuGraphicsGLRegisterBuffer(<cydriver.CUgraphicsResource*>pCudaResource._pvt_ptr, cybuffer, Flags)
-    return (CUresult(err), pCudaResource)
+    return (_dict_CUresult[err], pCudaResource)
 {{endif}}
 
 {{if True}}
@@ -51399,7 +51727,7 @@ def cuGraphicsGLRegisterImage(image, target, unsigned int Flags):
     cyimage = <cydriver.GLuint><void_ptr>pimage
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
     err = cydriver.cuGraphicsGLRegisterImage(<cydriver.CUgraphicsResource*>pCudaResource._pvt_ptr, cyimage, cytarget, Flags)
-    return (CUresult(err), pCudaResource)
+    return (_dict_CUresult[err], pCudaResource)
 {{endif}}
 
 {{if True}}
@@ -51465,7 +51793,7 @@ def cuGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : CUGLDevic
         pypCudaDevices = [CUdevice(init_value=<void_ptr>cypCudaDevices[idx]) for idx in range(cudaDeviceCount)]
     if cypCudaDevices is not NULL:
         free(cypCudaDevices)
-    return (CUresult(err), pCudaDeviceCount, pypCudaDevices)
+    return (_dict_CUresult[err], pCudaDeviceCount, pypCudaDevices)
 {{endif}}
 
 {{if True}}
@@ -51515,7 +51843,7 @@ def cuVDPAUGetDevice(vdpDevice, vdpGetProcAddress):
     cyvdpDevice = <cydriver.VdpDevice><void_ptr>pvdpDevice
     cdef CUdevice pDevice = CUdevice()
     err = cydriver.cuVDPAUGetDevice(<cydriver.CUdevice*>pDevice._pvt_ptr, cyvdpDevice, cyvdpGetProcAddress)
-    return (CUresult(err), pDevice)
+    return (_dict_CUresult[err], pDevice)
 {{endif}}
 
 {{if True}}
@@ -51580,7 +51908,7 @@ def cuVDPAUCtxCreate(unsigned int flags, device, vdpDevice, vdpGetProcAddress):
     cydevice = <cydriver.CUdevice>pdevice
     cdef CUcontext pCtx = CUcontext()
     err = cydriver.cuVDPAUCtxCreate(<cydriver.CUcontext*>pCtx._pvt_ptr, flags, cydevice, cyvdpDevice, cyvdpGetProcAddress)
-    return (CUresult(err), pCtx)
+    return (_dict_CUresult[err], pCtx)
 {{endif}}
 
 {{if True}}
@@ -51640,7 +51968,7 @@ def cuGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags):
     cyvdpSurface = <cydriver.VdpVideoSurface><void_ptr>pvdpSurface
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
     err = cydriver.cuGraphicsVDPAURegisterVideoSurface(<cydriver.CUgraphicsResource*>pCudaResource._pvt_ptr, cyvdpSurface, flags)
-    return (CUresult(err), pCudaResource)
+    return (_dict_CUresult[err], pCudaResource)
 {{endif}}
 
 {{if True}}
@@ -51700,7 +52028,7 @@ def cuGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags):
     cyvdpSurface = <cydriver.VdpOutputSurface><void_ptr>pvdpSurface
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
     err = cydriver.cuGraphicsVDPAURegisterOutputSurface(<cydriver.CUgraphicsResource*>pCudaResource._pvt_ptr, cyvdpSurface, flags)
-    return (CUresult(err), pCudaResource)
+    return (_dict_CUresult[err], pCudaResource)
 {{endif}}
 
 
diff --git a/cuda_bindings/cuda/bindings/nvrtc.pyx.in b/cuda_bindings/cuda/bindings/nvrtc.pyx.in
index d7ac3ebbe..c363f0f73 100644
--- a/cuda_bindings/cuda/bindings/nvrtc.pyx.in
+++ b/cuda_bindings/cuda/bindings/nvrtc.pyx.in
@@ -85,6 +85,8 @@ class nvrtcResult(IntEnum):
     NVRTC_ERROR_PCH_CREATE = cynvrtc.nvrtcResult.NVRTC_ERROR_PCH_CREATE{{endif}}
     {{if 'NVRTC_ERROR_CANCELLED' in found_values}}
     NVRTC_ERROR_CANCELLED = cynvrtc.nvrtcResult.NVRTC_ERROR_CANCELLED{{endif}}
+
+_dict_nvrtcResult = dict(((int(v), v) for k, v in nvrtcResult.__members__.items()))
 {{endif}}
 {{if 'nvrtcProgram' in found_types}}
 
@@ -159,7 +161,7 @@ def nvrtcVersion():
     cdef int major = 0
     cdef int minor = 0
     err = cynvrtc.nvrtcVersion(&major, &minor)
-    return (nvrtcResult(err), major, minor)
+    return (_dict_nvrtcResult[err], major, minor)
 {{endif}}
 
 {{if 'nvrtcGetNumSupportedArchs' in found_functions}}
@@ -180,7 +182,7 @@ def nvrtcGetNumSupportedArchs():
     """
     cdef int numArchs = 0
     err = cynvrtc.nvrtcGetNumSupportedArchs(&numArchs)
-    return (nvrtcResult(err), numArchs)
+    return (_dict_nvrtcResult[err], numArchs)
 {{endif}}
 
 {{if 'nvrtcGetSupportedArchs' in found_functions}}
@@ -204,7 +206,7 @@ def nvrtcGetSupportedArchs():
     supportedArchs.resize(s)
 
     err = cynvrtc.nvrtcGetSupportedArchs(supportedArchs.data())
-    return (nvrtcResult(err), supportedArchs)
+    return (_dict_nvrtcResult[err], supportedArchs)
 {{endif}}
 
 {{if 'nvrtcCreateProgram' in found_functions}}
@@ -259,7 +261,7 @@ def nvrtcCreateProgram(char* src, char* name, int numHeaders, headers : Optional
     cdef vector[const char*] cyheaders = headers
     cdef vector[const char*] cyincludeNames = includeNames
     err = cynvrtc.nvrtcCreateProgram(<cynvrtc.nvrtcProgram*>prog._pvt_ptr, src, name, numHeaders, cyheaders.data(), cyincludeNames.data())
-    return (nvrtcResult(err), prog)
+    return (_dict_nvrtcResult[err], prog)
 {{endif}}
 
 {{if 'nvrtcDestroyProgram' in found_functions}}
@@ -294,7 +296,7 @@ def nvrtcDestroyProgram(prog):
     else:
         raise TypeError("Argument 'prog' is not instance of type (expected <class 'int, nvrtc.nvrtcProgram'>, found " + str(type(prog)))
     err = cynvrtc.nvrtcDestroyProgram(cyprog)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcCompileProgram' in found_functions}}
@@ -343,7 +345,7 @@ def nvrtcCompileProgram(prog, int numOptions, options : Optional[Tuple[bytes] |
     if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
     cdef vector[const char*] cyoptions = options
     err = cynvrtc.nvrtcCompileProgram(cyprog, numOptions, cyoptions.data())
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetPTXSize' in found_functions}}
@@ -380,7 +382,7 @@ def nvrtcGetPTXSize(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t ptxSizeRet = 0
     err = cynvrtc.nvrtcGetPTXSize(cyprog, &ptxSizeRet)
-    return (nvrtcResult(err), ptxSizeRet)
+    return (_dict_nvrtcResult[err], ptxSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetPTX' in found_functions}}
@@ -416,7 +418,7 @@ def nvrtcGetPTX(prog, char* ptx):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetPTX(cyprog, ptx)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetCUBINSize' in found_functions}}
@@ -453,7 +455,7 @@ def nvrtcGetCUBINSize(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t cubinSizeRet = 0
     err = cynvrtc.nvrtcGetCUBINSize(cyprog, &cubinSizeRet)
-    return (nvrtcResult(err), cubinSizeRet)
+    return (_dict_nvrtcResult[err], cubinSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetCUBIN' in found_functions}}
@@ -489,7 +491,7 @@ def nvrtcGetCUBIN(prog, char* cubin):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetCUBIN(cyprog, cubin)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetNVVMSize' in found_functions}}
@@ -520,7 +522,7 @@ def nvrtcGetNVVMSize(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t nvvmSizeRet = 0
     err = cynvrtc.nvrtcGetNVVMSize(cyprog, &nvvmSizeRet)
-    return (nvrtcResult(err), nvvmSizeRet)
+    return (_dict_nvrtcResult[err], nvvmSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetNVVM' in found_functions}}
@@ -550,7 +552,7 @@ def nvrtcGetNVVM(prog, char* nvvm):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetNVVM(cyprog, nvvm)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetLTOIRSize' in found_functions}}
@@ -587,7 +589,7 @@ def nvrtcGetLTOIRSize(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t LTOIRSizeRet = 0
     err = cynvrtc.nvrtcGetLTOIRSize(cyprog, &LTOIRSizeRet)
-    return (nvrtcResult(err), LTOIRSizeRet)
+    return (_dict_nvrtcResult[err], LTOIRSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetLTOIR' in found_functions}}
@@ -623,7 +625,7 @@ def nvrtcGetLTOIR(prog, char* LTOIR):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetLTOIR(cyprog, LTOIR)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetOptiXIRSize' in found_functions}}
@@ -660,7 +662,7 @@ def nvrtcGetOptiXIRSize(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t optixirSizeRet = 0
     err = cynvrtc.nvrtcGetOptiXIRSize(cyprog, &optixirSizeRet)
-    return (nvrtcResult(err), optixirSizeRet)
+    return (_dict_nvrtcResult[err], optixirSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetOptiXIR' in found_functions}}
@@ -696,7 +698,7 @@ def nvrtcGetOptiXIR(prog, char* optixir):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetOptiXIR(cyprog, optixir)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetProgramLogSize' in found_functions}}
@@ -736,7 +738,7 @@ def nvrtcGetProgramLogSize(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t logSizeRet = 0
     err = cynvrtc.nvrtcGetProgramLogSize(cyprog, &logSizeRet)
-    return (nvrtcResult(err), logSizeRet)
+    return (_dict_nvrtcResult[err], logSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetProgramLog' in found_functions}}
@@ -772,7 +774,7 @@ def nvrtcGetProgramLog(prog, char* log):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetProgramLog(cyprog, log)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcAddNameExpression' in found_functions}}
@@ -813,7 +815,7 @@ def nvrtcAddNameExpression(prog, char* name_expression):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcAddNameExpression(cyprog, name_expression)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetLoweredName' in found_functions}}
@@ -855,7 +857,7 @@ def nvrtcGetLoweredName(prog, char* name_expression):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef const char* lowered_name = NULL
     err = cynvrtc.nvrtcGetLoweredName(cyprog, name_expression, &lowered_name)
-    return (nvrtcResult(err), <bytes>lowered_name if lowered_name != NULL else None)
+    return (_dict_nvrtcResult[err], <bytes>lowered_name if lowered_name != NULL else None)
 {{endif}}
 
 {{if 'nvrtcGetPCHHeapSize' in found_functions}}
@@ -874,7 +876,7 @@ def nvrtcGetPCHHeapSize():
     """
     cdef size_t ret = 0
     err = cynvrtc.nvrtcGetPCHHeapSize(&ret)
-    return (nvrtcResult(err), ret)
+    return (_dict_nvrtcResult[err], ret)
 {{endif}}
 
 {{if 'nvrtcSetPCHHeapSize' in found_functions}}
@@ -898,7 +900,7 @@ def nvrtcSetPCHHeapSize(size_t size):
         - :py:obj:`~.NVRTC_SUCCESS`
     """
     err = cynvrtc.nvrtcSetPCHHeapSize(size)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetPCHCreateStatus' in found_functions}}
@@ -945,7 +947,7 @@ def nvrtcGetPCHCreateStatus(prog):
         pprog = int(nvrtcProgram(prog))
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     err = cynvrtc.nvrtcGetPCHCreateStatus(cyprog)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 {{if 'nvrtcGetPCHHeapSizeRequired' in found_functions}}
@@ -979,7 +981,7 @@ def nvrtcGetPCHHeapSizeRequired(prog):
     cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t size = 0
     err = cynvrtc.nvrtcGetPCHHeapSizeRequired(cyprog, &size)
-    return (nvrtcResult(err), size)
+    return (_dict_nvrtcResult[err], size)
 {{endif}}
 
 {{if 'nvrtcSetFlowCallback' in found_functions}}
@@ -1039,7 +1041,7 @@ def nvrtcSetFlowCallback(prog, callback, payload):
     cypayload = utils.HelperInputVoidPtr(payload)
     cdef void* cypayload_ptr = <void*><void_ptr>cypayload.cptr
     err = cynvrtc.nvrtcSetFlowCallback(cyprog, cycallback_ptr, cypayload_ptr)
-    return (nvrtcResult(err),)
+    return (_dict_nvrtcResult[err],)
 {{endif}}
 
 @cython.embedsignature(True)
diff --git a/cuda_bindings/cuda/bindings/runtime.pyx.in b/cuda_bindings/cuda/bindings/runtime.pyx.in
index 97905c8cc..3c1efa776 100644
--- a/cuda_bindings/cuda/bindings/runtime.pyx.in
+++ b/cuda_bindings/cuda/bindings/runtime.pyx.in
@@ -1163,6 +1163,8 @@ class cudaError_t(IntEnum):
     cudaErrorUnknown = cyruntime.cudaError.cudaErrorUnknown{{endif}}
     {{if 'cudaErrorApiFailureBase' in found_values}}
     cudaErrorApiFailureBase = cyruntime.cudaError.cudaErrorApiFailureBase{{endif}}
+
+_dict_cudaError_t = dict(((int(v), v) for k, v in cudaError_t.__members__.items()))
 {{endif}}
 {{if 'cudaGraphDependencyType_enum' in found_types}}
 
@@ -1183,6 +1185,8 @@ class cudaGraphDependencyType(IntEnum):
     #: :py:obj:`~.cudaGraphKernelNodePortProgrammatic` or
     #: :py:obj:`~.cudaGraphKernelNodePortLaunchCompletion` outgoing port.
     cudaGraphDependencyTypeProgrammatic = cyruntime.cudaGraphDependencyType_enum.cudaGraphDependencyTypeProgrammatic{{endif}}
+
+_dict_cudaGraphDependencyType = dict(((int(v), v) for k, v in cudaGraphDependencyType.__members__.items()))
 {{endif}}
 {{if 'cudaGraphInstantiateResult' in found_types}}
 
@@ -1218,6 +1222,8 @@ class cudaGraphInstantiateResult(IntEnum):
     #: One or more conditional handles are not associated with conditional
     #: nodes
     cudaGraphInstantiateConditionalHandleUnused = cyruntime.cudaGraphInstantiateResult.cudaGraphInstantiateConditionalHandleUnused{{endif}}
+
+_dict_cudaGraphInstantiateResult = dict(((int(v), v) for k, v in cudaGraphInstantiateResult.__members__.items()))
 {{endif}}
 {{if 'cudaLaunchMemSyncDomain' in found_types}}
 
@@ -1250,6 +1256,8 @@ class cudaLaunchMemSyncDomain(IntEnum):
 
     #: Launch kernels in the remote domain
     cudaLaunchMemSyncDomainRemote = cyruntime.cudaLaunchMemSyncDomain.cudaLaunchMemSyncDomainRemote{{endif}}
+
+_dict_cudaLaunchMemSyncDomain = dict(((int(v), v) for k, v in cudaLaunchMemSyncDomain.__members__.items()))
 {{endif}}
 {{if 'cudaLaunchAttributeID' in found_types}}
 
@@ -1439,6 +1447,8 @@ class cudaLaunchAttributeID(IntEnum):
     #: only a hint, and the driver can choose a different configuration if
     #: required for the launch.
     cudaLaunchAttributePreferredSharedMemoryCarveout = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout{{endif}}
+
+_dict_cudaLaunchAttributeID = dict(((int(v), v) for k, v in cudaLaunchAttributeID.__members__.items()))
 {{endif}}
 {{if 'cudaAsyncNotificationType_enum' in found_types}}
 
@@ -1448,6 +1458,8 @@ class cudaAsyncNotificationType(IntEnum):
     """
     {{if 'cudaAsyncNotificationTypeOverBudget' in found_values}}
     cudaAsyncNotificationTypeOverBudget = cyruntime.cudaAsyncNotificationType_enum.cudaAsyncNotificationTypeOverBudget{{endif}}
+
+_dict_cudaAsyncNotificationType = dict(((int(v), v) for k, v in cudaAsyncNotificationType.__members__.items()))
 {{endif}}
 {{if 'cudaDataType_t' in found_types}}
 
@@ -1523,6 +1535,8 @@ class cudaDataType(IntEnum):
     CUDA_R_6F_E3M2 = cyruntime.cudaDataType_t.CUDA_R_6F_E3M2{{endif}}
     {{if 'CUDA_R_4F_E2M1' in found_values}}
     CUDA_R_4F_E2M1 = cyruntime.cudaDataType_t.CUDA_R_4F_E2M1{{endif}}
+
+_dict_cudaDataType = dict(((int(v), v) for k, v in cudaDataType.__members__.items()))
 {{endif}}
 {{if 'libraryPropertyType_t' in found_types}}
 
@@ -1534,6 +1548,8 @@ class libraryPropertyType(IntEnum):
     MINOR_VERSION = cyruntime.libraryPropertyType_t.MINOR_VERSION{{endif}}
     {{if 'PATCH_LEVEL' in found_values}}
     PATCH_LEVEL = cyruntime.libraryPropertyType_t.PATCH_LEVEL{{endif}}
+
+_dict_libraryPropertyType = dict(((int(v), v) for k, v in libraryPropertyType.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -1549,6 +1565,8 @@ class cudaEglFrameType(IntEnum):
 
     #: Frame type CUDA pointer
     cudaEglFrameTypePitch = cyruntime.cudaEglFrameType_enum.cudaEglFrameTypePitch{{endif}}
+
+_dict_cudaEglFrameType = dict(((int(v), v) for k, v in cudaEglFrameType.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -1574,6 +1592,8 @@ class cudaEglResourceLocationFlags(IntEnum):
 
     #: Resource location vidmem
     cudaEglResourceLocationVidmem = cyruntime.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationVidmem{{endif}}
+
+_dict_cudaEglResourceLocationFlags = dict(((int(v), v) for k, v in cudaEglResourceLocationFlags.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -2128,6 +2148,8 @@ class cudaEglColorFormat(IntEnum):
 
     #: Y, U, V in one surface, interleaved as UYVY in one channel.
     cudaEglColorFormatUYVY2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY2020{{endif}}
+
+_dict_cudaEglColorFormat = dict(((int(v), v) for k, v in cudaEglColorFormat.__members__.items()))
 {{endif}}
 {{if 'cudaChannelFormatKind' in found_types}}
 
@@ -2277,6 +2299,8 @@ class cudaChannelFormatKind(IntEnum):
 
     #: 4 channel unsigned normalized (10-bit, 10-bit, 10-bit, 2-bit) format
     cudaChannelFormatKindUnsignedNormalized1010102 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102{{endif}}
+
+_dict_cudaChannelFormatKind = dict(((int(v), v) for k, v in cudaChannelFormatKind.__members__.items()))
 {{endif}}
 {{if 'cudaMemoryType' in found_types}}
 
@@ -2300,6 +2324,8 @@ class cudaMemoryType(IntEnum):
 
     #: Managed memory
     cudaMemoryTypeManaged = cyruntime.cudaMemoryType.cudaMemoryTypeManaged{{endif}}
+
+_dict_cudaMemoryType = dict(((int(v), v) for k, v in cudaMemoryType.__members__.items()))
 {{endif}}
 {{if 'cudaMemcpyKind' in found_types}}
 
@@ -2328,6 +2354,8 @@ class cudaMemcpyKind(IntEnum):
     #: Direction of the transfer is inferred from the pointer values.
     #: Requires unified virtual addressing
     cudaMemcpyDefault = cyruntime.cudaMemcpyKind.cudaMemcpyDefault{{endif}}
+
+_dict_cudaMemcpyKind = dict(((int(v), v) for k, v in cudaMemcpyKind.__members__.items()))
 {{endif}}
 {{if 'cudaAccessProperty' in found_types}}
 
@@ -2348,6 +2376,8 @@ class cudaAccessProperty(IntEnum):
 
     #: Persisting access is more likely to persist in cache.
     cudaAccessPropertyPersisting = cyruntime.cudaAccessProperty.cudaAccessPropertyPersisting{{endif}}
+
+_dict_cudaAccessProperty = dict(((int(v), v) for k, v in cudaAccessProperty.__members__.items()))
 {{endif}}
 {{if 'cudaStreamCaptureStatus' in found_types}}
 
@@ -2369,6 +2399,8 @@ class cudaStreamCaptureStatus(IntEnum):
     #: Stream is part of a capture sequence that has been invalidated, but
     #: not terminated
     cudaStreamCaptureStatusInvalidated = cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusInvalidated{{endif}}
+
+_dict_cudaStreamCaptureStatus = dict(((int(v), v) for k, v in cudaStreamCaptureStatus.__members__.items()))
 {{endif}}
 {{if 'cudaStreamCaptureMode' in found_types}}
 
@@ -2384,6 +2416,8 @@ class cudaStreamCaptureMode(IntEnum):
     cudaStreamCaptureModeThreadLocal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeThreadLocal{{endif}}
     {{if 'cudaStreamCaptureModeRelaxed' in found_values}}
     cudaStreamCaptureModeRelaxed = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeRelaxed{{endif}}
+
+_dict_cudaStreamCaptureMode = dict(((int(v), v) for k, v in cudaStreamCaptureMode.__members__.items()))
 {{endif}}
 {{if 'cudaSynchronizationPolicy' in found_types}}
 
@@ -2399,6 +2433,8 @@ class cudaSynchronizationPolicy(IntEnum):
     cudaSyncPolicyYield = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyYield{{endif}}
     {{if 'cudaSyncPolicyBlockingSync' in found_values}}
     cudaSyncPolicyBlockingSync = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyBlockingSync{{endif}}
+
+_dict_cudaSynchronizationPolicy = dict(((int(v), v) for k, v in cudaSynchronizationPolicy.__members__.items()))
 {{endif}}
 {{if 'cudaClusterSchedulingPolicy' in found_types}}
 
@@ -2420,6 +2456,8 @@ class cudaClusterSchedulingPolicy(IntEnum):
     #: allow the hardware to load-balance the blocks in a cluster to the
     #: SMs
     cudaClusterSchedulingPolicyLoadBalancing = cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyLoadBalancing{{endif}}
+
+_dict_cudaClusterSchedulingPolicy = dict(((int(v), v) for k, v in cudaClusterSchedulingPolicy.__members__.items()))
 {{endif}}
 {{if 'cudaStreamUpdateCaptureDependenciesFlags' in found_types}}
 
@@ -2435,6 +2473,8 @@ class cudaStreamUpdateCaptureDependenciesFlags(IntEnum):
 
     #: Replace the dependency set with the new nodes
     cudaStreamSetCaptureDependencies = cyruntime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamSetCaptureDependencies{{endif}}
+
+_dict_cudaStreamUpdateCaptureDependenciesFlags = dict(((int(v), v) for k, v in cudaStreamUpdateCaptureDependenciesFlags.__members__.items()))
 {{endif}}
 {{if 'cudaUserObjectFlags' in found_types}}
 
@@ -2447,6 +2487,8 @@ class cudaUserObjectFlags(IntEnum):
     #: Indicates the destructor execution is not synchronized by any CUDA
     #: handle.
     cudaUserObjectNoDestructorSync = cyruntime.cudaUserObjectFlags.cudaUserObjectNoDestructorSync{{endif}}
+
+_dict_cudaUserObjectFlags = dict(((int(v), v) for k, v in cudaUserObjectFlags.__members__.items()))
 {{endif}}
 {{if 'cudaUserObjectRetainFlags' in found_types}}
 
@@ -2459,6 +2501,8 @@ class cudaUserObjectRetainFlags(IntEnum):
     #: Transfer references from the caller rather than creating new
     #: references.
     cudaGraphUserObjectMove = cyruntime.cudaUserObjectRetainFlags.cudaGraphUserObjectMove{{endif}}
+
+_dict_cudaUserObjectRetainFlags = dict(((int(v), v) for k, v in cudaUserObjectRetainFlags.__members__.items()))
 {{endif}}
 {{if 'cudaGraphicsRegisterFlags' in found_types}}
 
@@ -2486,6 +2530,8 @@ class cudaGraphicsRegisterFlags(IntEnum):
 
     #: CUDA will perform texture gather operations on this resource
     cudaGraphicsRegisterFlagsTextureGather = cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsTextureGather{{endif}}
+
+_dict_cudaGraphicsRegisterFlags = dict(((int(v), v) for k, v in cudaGraphicsRegisterFlags.__members__.items()))
 {{endif}}
 {{if 'cudaGraphicsMapFlags' in found_types}}
 
@@ -2505,6 +2551,8 @@ class cudaGraphicsMapFlags(IntEnum):
 
     #: CUDA will only write to and will not read from this resource
     cudaGraphicsMapFlagsWriteDiscard = cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsWriteDiscard{{endif}}
+
+_dict_cudaGraphicsMapFlags = dict(((int(v), v) for k, v in cudaGraphicsMapFlags.__members__.items()))
 {{endif}}
 {{if 'cudaGraphicsCubeFace' in found_types}}
 
@@ -2536,6 +2584,8 @@ class cudaGraphicsCubeFace(IntEnum):
 
     #: Negative Z face of cubemap
     cudaGraphicsCubeFaceNegativeZ = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeZ{{endif}}
+
+_dict_cudaGraphicsCubeFace = dict(((int(v), v) for k, v in cudaGraphicsCubeFace.__members__.items()))
 {{endif}}
 {{if 'cudaResourceType' in found_types}}
 
@@ -2559,6 +2609,8 @@ class cudaResourceType(IntEnum):
 
     #: Pitch 2D resource
     cudaResourceTypePitch2D = cyruntime.cudaResourceType.cudaResourceTypePitch2D{{endif}}
+
+_dict_cudaResourceType = dict(((int(v), v) for k, v in cudaResourceType.__members__.items()))
 {{endif}}
 {{if 'cudaResourceViewFormat' in found_types}}
 
@@ -2706,6 +2758,8 @@ class cudaResourceViewFormat(IntEnum):
 
     #: Block compressed 7
     cudaResViewFormatUnsignedBlockCompressed7 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed7{{endif}}
+
+_dict_cudaResourceViewFormat = dict(((int(v), v) for k, v in cudaResourceViewFormat.__members__.items()))
 {{endif}}
 {{if 'cudaFuncAttribute' in found_types}}
 
@@ -2749,6 +2803,8 @@ class cudaFuncAttribute(IntEnum):
     cudaFuncAttributeClusterSchedulingPolicyPreference = cyruntime.cudaFuncAttribute.cudaFuncAttributeClusterSchedulingPolicyPreference{{endif}}
     {{if 'cudaFuncAttributeMax' in found_values}}
     cudaFuncAttributeMax = cyruntime.cudaFuncAttribute.cudaFuncAttributeMax{{endif}}
+
+_dict_cudaFuncAttribute = dict(((int(v), v) for k, v in cudaFuncAttribute.__members__.items()))
 {{endif}}
 {{if 'cudaFuncCache' in found_types}}
 
@@ -2772,6 +2828,8 @@ class cudaFuncCache(IntEnum):
 
     #: Prefer equal size L1 cache and shared memory
     cudaFuncCachePreferEqual = cyruntime.cudaFuncCache.cudaFuncCachePreferEqual{{endif}}
+
+_dict_cudaFuncCache = dict(((int(v), v) for k, v in cudaFuncCache.__members__.items()))
 {{endif}}
 {{if 'cudaSharedMemConfig' in found_types}}
 
@@ -2785,6 +2843,8 @@ class cudaSharedMemConfig(IntEnum):
     cudaSharedMemBankSizeFourByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeFourByte{{endif}}
     {{if 'cudaSharedMemBankSizeEightByte' in found_values}}
     cudaSharedMemBankSizeEightByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeEightByte{{endif}}
+
+_dict_cudaSharedMemConfig = dict(((int(v), v) for k, v in cudaSharedMemConfig.__members__.items()))
 {{endif}}
 {{if 'cudaSharedCarveout' in found_types}}
 
@@ -2805,6 +2865,8 @@ class cudaSharedCarveout(IntEnum):
 
     #: Prefer maximum available shared memory, minimum L1 cache
     cudaSharedmemCarveoutMaxShared = cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutMaxShared{{endif}}
+
+_dict_cudaSharedCarveout = dict(((int(v), v) for k, v in cudaSharedCarveout.__members__.items()))
 {{endif}}
 {{if 'cudaComputeMode' in found_types}}
 
@@ -2832,6 +2894,8 @@ class cudaComputeMode(IntEnum):
     #: Compute-exclusive-process mode (Many threads in one process will be
     #: able to use :py:obj:`~.cudaSetDevice()` with this device)
     cudaComputeModeExclusiveProcess = cyruntime.cudaComputeMode.cudaComputeModeExclusiveProcess{{endif}}
+
+_dict_cudaComputeMode = dict(((int(v), v) for k, v in cudaComputeMode.__members__.items()))
 {{endif}}
 {{if 'cudaLimit' in found_types}}
 
@@ -2868,6 +2932,8 @@ class cudaLimit(IntEnum):
 
     #: A size in bytes for L2 persisting lines cache size
     cudaLimitPersistingL2CacheSize = cyruntime.cudaLimit.cudaLimitPersistingL2CacheSize{{endif}}
+
+_dict_cudaLimit = dict(((int(v), v) for k, v in cudaLimit.__members__.items()))
 {{endif}}
 {{if 'cudaMemoryAdvise' in found_types}}
 
@@ -2901,6 +2967,8 @@ class cudaMemoryAdvise(IntEnum):
     #: Let the Unified Memory subsystem decide on the page faulting policy
     #: for the specified device
     cudaMemAdviseUnsetAccessedBy = cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetAccessedBy{{endif}}
+
+_dict_cudaMemoryAdvise = dict(((int(v), v) for k, v in cudaMemoryAdvise.__members__.items()))
 {{endif}}
 {{if 'cudaMemRangeAttribute' in found_types}}
 
@@ -2942,6 +3010,8 @@ class cudaMemRangeAttribute(IntEnum):
 
     #: The last location id to which the range was prefetched
     cudaMemRangeAttributeLastPrefetchLocationId = cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocationId{{endif}}
+
+_dict_cudaMemRangeAttribute = dict(((int(v), v) for k, v in cudaMemRangeAttribute.__members__.items()))
 {{endif}}
 {{if 'cudaFlushGPUDirectRDMAWritesOptions' in found_types}}
 
@@ -2960,6 +3030,8 @@ class cudaFlushGPUDirectRDMAWritesOptions(IntEnum):
     #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported
     #: on the CUDA device.
     cudaFlushGPUDirectRDMAWritesOptionMemOps = cyruntime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionMemOps{{endif}}
+
+_dict_cudaFlushGPUDirectRDMAWritesOptions = dict(((int(v), v) for k, v in cudaFlushGPUDirectRDMAWritesOptions.__members__.items()))
 {{endif}}
 {{if 'cudaGPUDirectRDMAWritesOrdering' in found_types}}
 
@@ -2983,6 +3055,8 @@ class cudaGPUDirectRDMAWritesOrdering(IntEnum):
     #: Any CUDA device in the system can consistently consume GPUDirect
     #: RDMA writes to this device.
     cudaGPUDirectRDMAWritesOrderingAllDevices = cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingAllDevices{{endif}}
+
+_dict_cudaGPUDirectRDMAWritesOrdering = dict(((int(v), v) for k, v in cudaGPUDirectRDMAWritesOrdering.__members__.items()))
 {{endif}}
 {{if 'cudaFlushGPUDirectRDMAWritesScope' in found_types}}
 
@@ -2999,6 +3073,8 @@ class cudaFlushGPUDirectRDMAWritesScope(IntEnum):
 
     #: Blocks until remote writes are visible to all CUDA device contexts.
     cudaFlushGPUDirectRDMAWritesToAllDevices = cyruntime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToAllDevices{{endif}}
+
+_dict_cudaFlushGPUDirectRDMAWritesScope = dict(((int(v), v) for k, v in cudaFlushGPUDirectRDMAWritesScope.__members__.items()))
 {{endif}}
 {{if 'cudaFlushGPUDirectRDMAWritesTarget' in found_types}}
 
@@ -3011,6 +3087,8 @@ class cudaFlushGPUDirectRDMAWritesTarget(IntEnum):
     #: Sets the target for :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()`
     #: to the currently active CUDA device context.
     cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = cyruntime.cudaFlushGPUDirectRDMAWritesTarget.cudaFlushGPUDirectRDMAWritesTargetCurrentDevice{{endif}}
+
+_dict_cudaFlushGPUDirectRDMAWritesTarget = dict(((int(v), v) for k, v in cudaFlushGPUDirectRDMAWritesTarget.__members__.items()))
 {{endif}}
 {{if 'cudaDeviceAttr' in found_types}}
 
@@ -3553,6 +3631,8 @@ class cudaDeviceAttr(IntEnum):
     cudaDevAttrHostNumaMultinodeIpcSupported = cyruntime.cudaDeviceAttr.cudaDevAttrHostNumaMultinodeIpcSupported{{endif}}
     {{if 'cudaDevAttrMax' in found_values}}
     cudaDevAttrMax = cyruntime.cudaDeviceAttr.cudaDevAttrMax{{endif}}
+
+_dict_cudaDeviceAttr = dict(((int(v), v) for k, v in cudaDeviceAttr.__members__.items()))
 {{endif}}
 {{if 'cudaMemPoolAttr' in found_types}}
 
@@ -3609,6 +3689,8 @@ class cudaMemPoolAttr(IntEnum):
     #: from the pool that was in use by the application since the last time
     #: it was reset. High watermark can only be reset to zero.
     cudaMemPoolAttrUsedMemHigh = cyruntime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemHigh{{endif}}
+
+_dict_cudaMemPoolAttr = dict(((int(v), v) for k, v in cudaMemPoolAttr.__members__.items()))
 {{endif}}
 {{if 'cudaMemLocationType' in found_types}}
 
@@ -3635,6 +3717,8 @@ class cudaMemLocationType(IntEnum):
     #: Location is the host NUMA node closest to the current thread's CPU,
     #: id is ignored
     cudaMemLocationTypeHostNumaCurrent = cyruntime.cudaMemLocationType.cudaMemLocationTypeHostNumaCurrent{{endif}}
+
+_dict_cudaMemLocationType = dict(((int(v), v) for k, v in cudaMemLocationType.__members__.items()))
 {{endif}}
 {{if 'cudaMemAccessFlags' in found_types}}
 
@@ -3654,6 +3738,8 @@ class cudaMemAccessFlags(IntEnum):
 
     #: Make the address range read-write accessible
     cudaMemAccessFlagsProtReadWrite = cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtReadWrite{{endif}}
+
+_dict_cudaMemAccessFlags = dict(((int(v), v) for k, v in cudaMemAccessFlags.__members__.items()))
 {{endif}}
 {{if 'cudaMemAllocationType' in found_types}}
 
@@ -3670,6 +3756,8 @@ class cudaMemAllocationType(IntEnum):
     cudaMemAllocationTypePinned = cyruntime.cudaMemAllocationType.cudaMemAllocationTypePinned{{endif}}
     {{if 'cudaMemAllocationTypeMax' in found_values}}
     cudaMemAllocationTypeMax = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeMax{{endif}}
+
+_dict_cudaMemAllocationType = dict(((int(v), v) for k, v in cudaMemAllocationType.__members__.items()))
 {{endif}}
 {{if 'cudaMemAllocationHandleType' in found_types}}
 
@@ -3699,6 +3787,8 @@ class cudaMemAllocationHandleType(IntEnum):
     #: Allows a fabric handle to be used for exporting.
     #: (cudaMemFabricHandle_t)
     cudaMemHandleTypeFabric = cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeFabric{{endif}}
+
+_dict_cudaMemAllocationHandleType = dict(((int(v), v) for k, v in cudaMemAllocationHandleType.__members__.items()))
 {{endif}}
 {{if 'cudaGraphMemAttributeType' in found_types}}
 
@@ -3728,6 +3818,8 @@ class cudaGraphMemAttributeType(IntEnum):
     #: currently allocated for use by the CUDA graphs asynchronous
     #: allocator.
     cudaGraphMemAttrReservedMemHigh = cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemHigh{{endif}}
+
+_dict_cudaGraphMemAttributeType = dict(((int(v), v) for k, v in cudaGraphMemAttributeType.__members__.items()))
 {{endif}}
 {{if 'cudaMemcpyFlags' in found_types}}
 
@@ -3743,6 +3835,8 @@ class cudaMemcpyFlags(IntEnum):
     #: Hint to the driver to try and overlap the copy with compute work on
     #: the SMs.
     cudaMemcpyFlagPreferOverlapWithCompute = cyruntime.cudaMemcpyFlags.cudaMemcpyFlagPreferOverlapWithCompute{{endif}}
+
+_dict_cudaMemcpyFlags = dict(((int(v), v) for k, v in cudaMemcpyFlags.__members__.items()))
 {{endif}}
 {{if 'cudaMemcpySrcAccessOrder' in found_types}}
 
@@ -3781,6 +3875,8 @@ class cudaMemcpySrcAccessOrder(IntEnum):
     cudaMemcpySrcAccessOrderAny = cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderAny{{endif}}
     {{if 'cudaMemcpySrcAccessOrderMax' in found_values}}
     cudaMemcpySrcAccessOrderMax = cyruntime.cudaMemcpySrcAccessOrder.cudaMemcpySrcAccessOrderMax{{endif}}
+
+_dict_cudaMemcpySrcAccessOrder = dict(((int(v), v) for k, v in cudaMemcpySrcAccessOrder.__members__.items()))
 {{endif}}
 {{if 'cudaMemcpy3DOperandType' in found_types}}
 
@@ -3799,6 +3895,8 @@ class cudaMemcpy3DOperandType(IntEnum):
     cudaMemcpyOperandTypeArray = cyruntime.cudaMemcpy3DOperandType.cudaMemcpyOperandTypeArray{{endif}}
     {{if 'cudaMemcpyOperandTypeMax' in found_values}}
     cudaMemcpyOperandTypeMax = cyruntime.cudaMemcpy3DOperandType.cudaMemcpyOperandTypeMax{{endif}}
+
+_dict_cudaMemcpy3DOperandType = dict(((int(v), v) for k, v in cudaMemcpy3DOperandType.__members__.items()))
 {{endif}}
 {{if 'cudaDeviceP2PAttr' in found_types}}
 
@@ -3823,6 +3921,8 @@ class cudaDeviceP2PAttr(IntEnum):
 
     #: Accessing CUDA arrays over the link supported
     cudaDevP2PAttrCudaArrayAccessSupported = cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrCudaArrayAccessSupported{{endif}}
+
+_dict_cudaDeviceP2PAttr = dict(((int(v), v) for k, v in cudaDeviceP2PAttr.__members__.items()))
 {{endif}}
 {{if 'cudaExternalMemoryHandleType' in found_types}}
 
@@ -3862,6 +3962,8 @@ class cudaExternalMemoryHandleType(IntEnum):
 
     #: Handle is an NvSciBuf object
     cudaExternalMemoryHandleTypeNvSciBuf = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf{{endif}}
+
+_dict_cudaExternalMemoryHandleType = dict(((int(v), v) for k, v in cudaExternalMemoryHandleType.__members__.items()))
 {{endif}}
 {{if 'cudaExternalSemaphoreHandleType' in found_types}}
 
@@ -3911,6 +4013,8 @@ class cudaExternalSemaphoreHandleType(IntEnum):
     #: Handle is an opaque handle file descriptor referencing a timeline
     #: semaphore
     cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32{{endif}}
+
+_dict_cudaExternalSemaphoreHandleType = dict(((int(v), v) for k, v in cudaExternalSemaphoreHandleType.__members__.items()))
 {{endif}}
 {{if 'cudaJitOption' in found_types}}
 
@@ -4058,6 +4162,8 @@ class cudaJitOption(IntEnum):
     #: directives. (0: Disable, default; 1: Enable) Option type: int
     #: Applies to: compiler only
     cudaJitOverrideDirectiveValues = cyruntime.cudaJitOption.cudaJitOverrideDirectiveValues{{endif}}
+
+_dict_cudaJitOption = dict(((int(v), v) for k, v in cudaJitOption.__members__.items()))
 {{endif}}
 {{if 'cudaLibraryOption' in found_types}}
 
@@ -4081,6 +4187,8 @@ class cudaLibraryOption(IntEnum):
     #: :py:obj:`~.cudaLibraryLoadFromFile()` is invalid and will return
     #: :py:obj:`~.cudaErrorInvalidValue`.
     cudaLibraryBinaryIsPreserved = cyruntime.cudaLibraryOption.cudaLibraryBinaryIsPreserved{{endif}}
+
+_dict_cudaLibraryOption = dict(((int(v), v) for k, v in cudaLibraryOption.__members__.items()))
 {{endif}}
 {{if 'cudaJit_CacheMode' in found_types}}
 
@@ -4100,6 +4208,8 @@ class cudaJit_CacheMode(IntEnum):
 
     #: Compile with L1 cache enabled
     cudaJitCacheOptionCA = cyruntime.cudaJit_CacheMode.cudaJitCacheOptionCA{{endif}}
+
+_dict_cudaJit_CacheMode = dict(((int(v), v) for k, v in cudaJit_CacheMode.__members__.items()))
 {{endif}}
 {{if 'cudaJit_Fallback' in found_types}}
 
@@ -4116,6 +4226,8 @@ class cudaJit_Fallback(IntEnum):
     #: Prefer to fall back to compatible binary code if exact match not
     #: found
     cudaPreferBinary = cyruntime.cudaJit_Fallback.cudaPreferBinary{{endif}}
+
+_dict_cudaJit_Fallback = dict(((int(v), v) for k, v in cudaJit_Fallback.__members__.items()))
 {{endif}}
 {{if 'cudaCGScope' in found_types}}
 
@@ -4135,6 +4247,8 @@ class cudaCGScope(IntEnum):
 
     #: Scope represented by a multi_grid_group
     cudaCGScopeMultiGrid = cyruntime.cudaCGScope.cudaCGScopeMultiGrid{{endif}}
+
+_dict_cudaCGScope = dict(((int(v), v) for k, v in cudaCGScope.__members__.items()))
 {{endif}}
 {{if 'cudaGraphConditionalHandleFlags' in found_types}}
 
@@ -4146,6 +4260,8 @@ class cudaGraphConditionalHandleFlags(IntEnum):
 
     #: Apply default handle value when graph is launched.
     cudaGraphCondAssignDefault = cyruntime.cudaGraphConditionalHandleFlags.cudaGraphCondAssignDefault{{endif}}
+
+_dict_cudaGraphConditionalHandleFlags = dict(((int(v), v) for k, v in cudaGraphConditionalHandleFlags.__members__.items()))
 {{endif}}
 {{if 'cudaGraphConditionalNodeType' in found_types}}
 
@@ -4170,6 +4286,8 @@ class cudaGraphConditionalNodeType(IntEnum):
     #: the value of the condition. If the condition does not match a body
     #: index, no body is launched.
     cudaGraphCondTypeSwitch = cyruntime.cudaGraphConditionalNodeType.cudaGraphCondTypeSwitch{{endif}}
+
+_dict_cudaGraphConditionalNodeType = dict(((int(v), v) for k, v in cudaGraphConditionalNodeType.__members__.items()))
 {{endif}}
 {{if 'cudaGraphNodeType' in found_types}}
 
@@ -4255,6 +4373,8 @@ class cudaGraphNodeType(IntEnum):
     cudaGraphNodeTypeConditional = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeConditional{{endif}}
     {{if 'cudaGraphNodeTypeCount' in found_values}}
     cudaGraphNodeTypeCount = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeCount{{endif}}
+
+_dict_cudaGraphNodeType = dict(((int(v), v) for k, v in cudaGraphNodeType.__members__.items()))
 {{endif}}
 {{if 'cudaGraphExecUpdateResult' in found_types}}
 
@@ -4303,6 +4423,8 @@ class cudaGraphExecUpdateResult(IntEnum):
     #: The update failed because the node attributes changed in a way that
     #: is not supported
     cudaGraphExecUpdateErrorAttributesChanged = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorAttributesChanged{{endif}}
+
+_dict_cudaGraphExecUpdateResult = dict(((int(v), v) for k, v in cudaGraphExecUpdateResult.__members__.items()))
 {{endif}}
 {{if 'cudaGraphKernelNodeField' in found_types}}
 
@@ -4327,6 +4449,8 @@ class cudaGraphKernelNodeField(IntEnum):
 
     #: Node enable/disable
     cudaGraphKernelNodeFieldEnabled = cyruntime.cudaGraphKernelNodeField.cudaGraphKernelNodeFieldEnabled{{endif}}
+
+_dict_cudaGraphKernelNodeField = dict(((int(v), v) for k, v in cudaGraphKernelNodeField.__members__.items()))
 {{endif}}
 {{if 'cudaGetDriverEntryPointFlags' in found_types}}
 
@@ -4348,6 +4472,8 @@ class cudaGetDriverEntryPointFlags(IntEnum):
 
     #: Search for per-thread versions of driver symbols.
     cudaEnablePerThreadDefaultStream = cyruntime.cudaGetDriverEntryPointFlags.cudaEnablePerThreadDefaultStream{{endif}}
+
+_dict_cudaGetDriverEntryPointFlags = dict(((int(v), v) for k, v in cudaGetDriverEntryPointFlags.__members__.items()))
 {{endif}}
 {{if 'cudaDriverEntryPointQueryResult' in found_types}}
 
@@ -4368,6 +4494,8 @@ class cudaDriverEntryPointQueryResult(IntEnum):
 
     #: Search for symbol was found but version wasn't great enough
     cudaDriverEntryPointVersionNotSufficent = cyruntime.cudaDriverEntryPointQueryResult.cudaDriverEntryPointVersionNotSufficent{{endif}}
+
+_dict_cudaDriverEntryPointQueryResult = dict(((int(v), v) for k, v in cudaDriverEntryPointQueryResult.__members__.items()))
 {{endif}}
 {{if 'cudaGraphDebugDotFlags' in found_types}}
 
@@ -4420,6 +4548,8 @@ class cudaGraphDebugDotFlags(IntEnum):
 
     #: Adds :py:obj:`~.cudaConditionalNodeParams` to output
     cudaGraphDebugDotFlagsConditionalNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsConditionalNodeParams{{endif}}
+
+_dict_cudaGraphDebugDotFlags = dict(((int(v), v) for k, v in cudaGraphDebugDotFlags.__members__.items()))
 {{endif}}
 {{if 'cudaGraphInstantiateFlags' in found_types}}
 
@@ -4452,6 +4582,8 @@ class cudaGraphInstantiateFlags(IntEnum):
     #: Run the graph using the per-node priority attributes rather than the
     #: priority of the stream it is launched into.
     cudaGraphInstantiateFlagUseNodePriority = cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagUseNodePriority{{endif}}
+
+_dict_cudaGraphInstantiateFlags = dict(((int(v), v) for k, v in cudaGraphInstantiateFlags.__members__.items()))
 {{endif}}
 {{if 'cudaDeviceNumaConfig' in found_types}}
 
@@ -4467,6 +4599,8 @@ class cudaDeviceNumaConfig(IntEnum):
 
     #: The GPU is a NUMA node, cudaDevAttrNumaId contains its NUMA ID
     cudaDeviceNumaConfigNumaNode = cyruntime.cudaDeviceNumaConfig.cudaDeviceNumaConfigNumaNode{{endif}}
+
+_dict_cudaDeviceNumaConfig = dict(((int(v), v) for k, v in cudaDeviceNumaConfig.__members__.items()))
 {{endif}}
 {{if 'cudaSurfaceBoundaryMode' in found_types}}
 
@@ -4486,6 +4620,8 @@ class cudaSurfaceBoundaryMode(IntEnum):
 
     #: Trap boundary mode
     cudaBoundaryModeTrap = cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeTrap{{endif}}
+
+_dict_cudaSurfaceBoundaryMode = dict(((int(v), v) for k, v in cudaSurfaceBoundaryMode.__members__.items()))
 {{endif}}
 {{if 'cudaSurfaceFormatMode' in found_types}}
 
@@ -4501,6 +4637,8 @@ class cudaSurfaceFormatMode(IntEnum):
 
     #: Auto format mode
     cudaFormatModeAuto = cyruntime.cudaSurfaceFormatMode.cudaFormatModeAuto{{endif}}
+
+_dict_cudaSurfaceFormatMode = dict(((int(v), v) for k, v in cudaSurfaceFormatMode.__members__.items()))
 {{endif}}
 {{if 'cudaTextureAddressMode' in found_types}}
 
@@ -4524,6 +4662,8 @@ class cudaTextureAddressMode(IntEnum):
 
     #: Border address mode
     cudaAddressModeBorder = cyruntime.cudaTextureAddressMode.cudaAddressModeBorder{{endif}}
+
+_dict_cudaTextureAddressMode = dict(((int(v), v) for k, v in cudaTextureAddressMode.__members__.items()))
 {{endif}}
 {{if 'cudaTextureFilterMode' in found_types}}
 
@@ -4539,6 +4679,8 @@ class cudaTextureFilterMode(IntEnum):
 
     #: Linear filter mode
     cudaFilterModeLinear = cyruntime.cudaTextureFilterMode.cudaFilterModeLinear{{endif}}
+
+_dict_cudaTextureFilterMode = dict(((int(v), v) for k, v in cudaTextureFilterMode.__members__.items()))
 {{endif}}
 {{if 'cudaTextureReadMode' in found_types}}
 
@@ -4554,6 +4696,8 @@ class cudaTextureReadMode(IntEnum):
 
     #: Read texture as normalized float
     cudaReadModeNormalizedFloat = cyruntime.cudaTextureReadMode.cudaReadModeNormalizedFloat{{endif}}
+
+_dict_cudaTextureReadMode = dict(((int(v), v) for k, v in cudaTextureReadMode.__members__.items()))
 {{endif}}
 {{if 'cudaRoundMode' in found_types}}
 
@@ -4567,6 +4711,8 @@ class cudaRoundMode(IntEnum):
     cudaRoundPosInf = cyruntime.cudaRoundMode.cudaRoundPosInf{{endif}}
     {{if 'cudaRoundMinInf' in found_values}}
     cudaRoundMinInf = cyruntime.cudaRoundMode.cudaRoundMinInf{{endif}}
+
+_dict_cudaRoundMode = dict(((int(v), v) for k, v in cudaRoundMode.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -4588,6 +4734,8 @@ class cudaGLDeviceList(IntEnum):
     #: The CUDA devices for the GPUs to be used by the current OpenGL
     #: context in the next frame
     cudaGLDeviceListNextFrame = cyruntime.cudaGLDeviceList.cudaGLDeviceListNextFrame{{endif}}
+
+_dict_cudaGLDeviceList = dict(((int(v), v) for k, v in cudaGLDeviceList.__members__.items()))
 {{endif}}
 {{if True}}
 
@@ -4607,6 +4755,8 @@ class cudaGLMapFlags(IntEnum):
 
     #: CUDA kernels will only write to and will not read from this resource
     cudaGLMapFlagsWriteDiscard = cyruntime.cudaGLMapFlags.cudaGLMapFlagsWriteDiscard{{endif}}
+
+_dict_cudaGLMapFlags = dict(((int(v), v) for k, v in cudaGLMapFlags.__members__.items()))
 {{endif}}
 {{if 'cudaLaunchAttributeID' in found_types}}
 
@@ -4796,6 +4946,8 @@ class cudaStreamAttrID(IntEnum):
     #: only a hint, and the driver can choose a different configuration if
     #: required for the launch.
     cudaLaunchAttributePreferredSharedMemoryCarveout = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout{{endif}}
+
+_dict_cudaLaunchAttributeID = dict(((int(v), v) for k, v in cudaLaunchAttributeID.__members__.items()))
 {{endif}}
 {{if 'cudaLaunchAttributeID' in found_types}}
 
@@ -4985,6 +5137,8 @@ class cudaKernelNodeAttrID(IntEnum):
     #: only a hint, and the driver can choose a different configuration if
     #: required for the launch.
     cudaLaunchAttributePreferredSharedMemoryCarveout = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePreferredSharedMemoryCarveout{{endif}}
+
+_dict_cudaLaunchAttributeID = dict(((int(v), v) for k, v in cudaLaunchAttributeID.__members__.items()))
 {{endif}}
 {{if 'cudaArray_t' in found_types}}
 
@@ -5701,7 +5855,9 @@ cdef class cudaChannelFormatDesc:
     {{if 'cudaChannelFormatDesc.f' in found_struct}}
     @property
     def f(self):
-        return cudaChannelFormatKind(self._pvt_ptr[0].f)
+        if self._pvt_ptr[0].f not in _dict_cudaChannelFormatKind:
+            return None
+        return _dict_cudaChannelFormatKind[self._pvt_ptr[0].f]
     @f.setter
     def f(self, f not None : cudaChannelFormatKind):
         self._pvt_ptr[0].f = f.value
@@ -6487,7 +6643,9 @@ cdef class cudaMemcpy3DParms:
     {{if 'cudaMemcpy3DParms.kind' in found_struct}}
     @property
     def kind(self):
-        return cudaMemcpyKind(self._pvt_ptr[0].kind)
+        if self._pvt_ptr[0].kind not in _dict_cudaMemcpyKind:
+            return None
+        return _dict_cudaMemcpyKind[self._pvt_ptr[0].kind]
     @kind.setter
     def kind(self, kind not None : cudaMemcpyKind):
         self._pvt_ptr[0].kind = kind.value
@@ -7217,7 +7375,9 @@ cdef class cudaAccessPolicyWindow:
     {{if 'cudaAccessPolicyWindow.hitProp' in found_struct}}
     @property
     def hitProp(self):
-        return cudaAccessProperty(self._pvt_ptr[0].hitProp)
+        if self._pvt_ptr[0].hitProp not in _dict_cudaAccessProperty:
+            return None
+        return _dict_cudaAccessProperty[self._pvt_ptr[0].hitProp]
     @hitProp.setter
     def hitProp(self, hitProp not None : cudaAccessProperty):
         self._pvt_ptr[0].hitProp = hitProp.value
@@ -7225,7 +7385,9 @@ cdef class cudaAccessPolicyWindow:
     {{if 'cudaAccessPolicyWindow.missProp' in found_struct}}
     @property
     def missProp(self):
-        return cudaAccessProperty(self._pvt_ptr[0].missProp)
+        if self._pvt_ptr[0].missProp not in _dict_cudaAccessProperty:
+            return None
+        return _dict_cudaAccessProperty[self._pvt_ptr[0].missProp]
     @missProp.setter
     def missProp(self, missProp not None : cudaAccessProperty):
         self._pvt_ptr[0].missProp = missProp.value
@@ -7888,7 +8050,9 @@ cdef class cudaResourceDesc:
     {{if 'cudaResourceDesc.resType' in found_struct}}
     @property
     def resType(self):
-        return cudaResourceType(self._pvt_ptr[0].resType)
+        if self._pvt_ptr[0].resType not in _dict_cudaResourceType:
+            return None
+        return _dict_cudaResourceType[self._pvt_ptr[0].resType]
     @resType.setter
     def resType(self, resType not None : cudaResourceType):
         self._pvt_ptr[0].resType = resType.value
@@ -8016,7 +8180,9 @@ cdef class cudaResourceViewDesc:
     {{if 'cudaResourceViewDesc.format' in found_struct}}
     @property
     def format(self):
-        return cudaResourceViewFormat(self._pvt_ptr[0].format)
+        if self._pvt_ptr[0].format not in _dict_cudaResourceViewFormat:
+            return None
+        return _dict_cudaResourceViewFormat[self._pvt_ptr[0].format]
     @format.setter
     def format(self, format not None : cudaResourceViewFormat):
         self._pvt_ptr[0].format = format.value
@@ -8163,7 +8329,9 @@ cdef class cudaPointerAttributes:
     {{if 'cudaPointerAttributes.type' in found_struct}}
     @property
     def type(self):
-        return cudaMemoryType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaMemoryType:
+            return None
+        return _dict_cudaMemoryType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaMemoryType):
         self._pvt_ptr[0].type = type.value
@@ -8627,7 +8795,9 @@ cdef class cudaMemLocation:
     {{if 'cudaMemLocation.type' in found_struct}}
     @property
     def type(self):
-        return cudaMemLocationType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaMemLocationType:
+            return None
+        return _dict_cudaMemLocationType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaMemLocationType):
         self._pvt_ptr[0].type = type.value
@@ -8706,7 +8876,9 @@ cdef class cudaMemAccessDesc:
     {{if 'cudaMemAccessDesc.flags' in found_struct}}
     @property
     def flags(self):
-        return cudaMemAccessFlags(self._pvt_ptr[0].flags)
+        if self._pvt_ptr[0].flags not in _dict_cudaMemAccessFlags:
+            return None
+        return _dict_cudaMemAccessFlags[self._pvt_ptr[0].flags]
     @flags.setter
     def flags(self, flags not None : cudaMemAccessFlags):
         self._pvt_ptr[0].flags = flags.value
@@ -8825,7 +8997,9 @@ cdef class cudaMemPoolProps:
     {{if 'cudaMemPoolProps.allocType' in found_struct}}
     @property
     def allocType(self):
-        return cudaMemAllocationType(self._pvt_ptr[0].allocType)
+        if self._pvt_ptr[0].allocType not in _dict_cudaMemAllocationType:
+            return None
+        return _dict_cudaMemAllocationType[self._pvt_ptr[0].allocType]
     @allocType.setter
     def allocType(self, allocType not None : cudaMemAllocationType):
         self._pvt_ptr[0].allocType = allocType.value
@@ -8833,7 +9007,9 @@ cdef class cudaMemPoolProps:
     {{if 'cudaMemPoolProps.handleTypes' in found_struct}}
     @property
     def handleTypes(self):
-        return cudaMemAllocationHandleType(self._pvt_ptr[0].handleTypes)
+        if self._pvt_ptr[0].handleTypes not in _dict_cudaMemAllocationHandleType:
+            return None
+        return _dict_cudaMemAllocationHandleType[self._pvt_ptr[0].handleTypes]
     @handleTypes.setter
     def handleTypes(self, handleTypes not None : cudaMemAllocationHandleType):
         self._pvt_ptr[0].handleTypes = handleTypes.value
@@ -9370,7 +9546,9 @@ cdef class cudaMemcpyAttributes:
     {{if 'cudaMemcpyAttributes.srcAccessOrder' in found_struct}}
     @property
     def srcAccessOrder(self):
-        return cudaMemcpySrcAccessOrder(self._pvt_ptr[0].srcAccessOrder)
+        if self._pvt_ptr[0].srcAccessOrder not in _dict_cudaMemcpySrcAccessOrder:
+            return None
+        return _dict_cudaMemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder]
     @srcAccessOrder.setter
     def srcAccessOrder(self, srcAccessOrder not None : cudaMemcpySrcAccessOrder):
         self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value
@@ -9798,7 +9976,9 @@ cdef class cudaMemcpy3DOperand:
     {{if 'cudaMemcpy3DOperand.type' in found_struct}}
     @property
     def type(self):
-        return cudaMemcpy3DOperandType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaMemcpy3DOperandType:
+            return None
+        return _dict_cudaMemcpy3DOperandType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaMemcpy3DOperandType):
         self._pvt_ptr[0].type = type.value
@@ -9928,7 +10108,9 @@ cdef class cudaMemcpy3DBatchOp:
     {{if 'cudaMemcpy3DBatchOp.srcAccessOrder' in found_struct}}
     @property
     def srcAccessOrder(self):
-        return cudaMemcpySrcAccessOrder(self._pvt_ptr[0].srcAccessOrder)
+        if self._pvt_ptr[0].srcAccessOrder not in _dict_cudaMemcpySrcAccessOrder:
+            return None
+        return _dict_cudaMemcpySrcAccessOrder[self._pvt_ptr[0].srcAccessOrder]
     @srcAccessOrder.setter
     def srcAccessOrder(self, srcAccessOrder not None : cudaMemcpySrcAccessOrder):
         self._pvt_ptr[0].srcAccessOrder = srcAccessOrder.value
@@ -12160,7 +12342,9 @@ cdef class cudaExternalMemoryHandleDesc:
     {{if 'cudaExternalMemoryHandleDesc.type' in found_struct}}
     @property
     def type(self):
-        return cudaExternalMemoryHandleType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaExternalMemoryHandleType:
+            return None
+        return _dict_cudaExternalMemoryHandleType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaExternalMemoryHandleType):
         self._pvt_ptr[0].type = type.value
@@ -12627,7 +12811,9 @@ cdef class cudaExternalSemaphoreHandleDesc:
     {{if 'cudaExternalSemaphoreHandleDesc.type' in found_struct}}
     @property
     def type(self):
-        return cudaExternalSemaphoreHandleType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaExternalSemaphoreHandleType:
+            return None
+        return _dict_cudaExternalSemaphoreHandleType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaExternalSemaphoreHandleType):
         self._pvt_ptr[0].type = type.value
@@ -14404,7 +14590,9 @@ cdef class cudaConditionalNodeParams:
     {{if 'cudaConditionalNodeParams.type' in found_struct}}
     @property
     def type(self):
-        return cudaGraphConditionalNodeType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaGraphConditionalNodeType:
+            return None
+        return _dict_cudaGraphConditionalNodeType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaGraphConditionalNodeType):
         self._pvt_ptr[0].type = type.value
@@ -14843,7 +15031,9 @@ cdef class cudaGraphNodeParams:
     {{if 'cudaGraphNodeParams.type' in found_struct}}
     @property
     def type(self):
-        return cudaGraphNodeType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaGraphNodeType:
+            return None
+        return _dict_cudaGraphNodeType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaGraphNodeType):
         self._pvt_ptr[0].type = type.value
@@ -15217,7 +15407,9 @@ cdef class cudaGraphInstantiateParams_st:
     {{if 'cudaGraphInstantiateParams_st.result_out' in found_struct}}
     @property
     def result_out(self):
-        return cudaGraphInstantiateResult(self._pvt_ptr[0].result_out)
+        if self._pvt_ptr[0].result_out not in _dict_cudaGraphInstantiateResult:
+            return None
+        return _dict_cudaGraphInstantiateResult[self._pvt_ptr[0].result_out]
     @result_out.setter
     def result_out(self, result_out not None : cudaGraphInstantiateResult):
         self._pvt_ptr[0].result_out = result_out.value
@@ -15296,7 +15488,9 @@ cdef class cudaGraphExecUpdateResultInfo_st:
     {{if 'cudaGraphExecUpdateResultInfo_st.result' in found_struct}}
     @property
     def result(self):
-        return cudaGraphExecUpdateResult(self._pvt_ptr[0].result)
+        if self._pvt_ptr[0].result not in _dict_cudaGraphExecUpdateResult:
+            return None
+        return _dict_cudaGraphExecUpdateResult[self._pvt_ptr[0].result]
     @result.setter
     def result(self, result not None : cudaGraphExecUpdateResult):
         self._pvt_ptr[0].result = result.value
@@ -15598,7 +15792,9 @@ cdef class cudaGraphKernelNodeUpdate:
     {{if 'cudaGraphKernelNodeUpdate.field' in found_struct}}
     @property
     def field(self):
-        return cudaGraphKernelNodeField(self._pvt_ptr[0].field)
+        if self._pvt_ptr[0].field not in _dict_cudaGraphKernelNodeField:
+            return None
+        return _dict_cudaGraphKernelNodeField[self._pvt_ptr[0].field]
     @field.setter
     def field(self, field not None : cudaGraphKernelNodeField):
         self._pvt_ptr[0].field = field.value
@@ -16377,7 +16573,9 @@ cdef class cudaLaunchAttributeValue:
     {{if 'cudaLaunchAttributeValue.syncPolicy' in found_struct}}
     @property
     def syncPolicy(self):
-        return cudaSynchronizationPolicy(self._pvt_ptr[0].syncPolicy)
+        if self._pvt_ptr[0].syncPolicy not in _dict_cudaSynchronizationPolicy:
+            return None
+        return _dict_cudaSynchronizationPolicy[self._pvt_ptr[0].syncPolicy]
     @syncPolicy.setter
     def syncPolicy(self, syncPolicy not None : cudaSynchronizationPolicy):
         self._pvt_ptr[0].syncPolicy = syncPolicy.value
@@ -16393,7 +16591,9 @@ cdef class cudaLaunchAttributeValue:
     {{if 'cudaLaunchAttributeValue.clusterSchedulingPolicyPreference' in found_struct}}
     @property
     def clusterSchedulingPolicyPreference(self):
-        return cudaClusterSchedulingPolicy(self._pvt_ptr[0].clusterSchedulingPolicyPreference)
+        if self._pvt_ptr[0].clusterSchedulingPolicyPreference not in _dict_cudaClusterSchedulingPolicy:
+            return None
+        return _dict_cudaClusterSchedulingPolicy[self._pvt_ptr[0].clusterSchedulingPolicyPreference]
     @clusterSchedulingPolicyPreference.setter
     def clusterSchedulingPolicyPreference(self, clusterSchedulingPolicyPreference not None : cudaClusterSchedulingPolicy):
         self._pvt_ptr[0].clusterSchedulingPolicyPreference = clusterSchedulingPolicyPreference.value
@@ -16433,7 +16633,9 @@ cdef class cudaLaunchAttributeValue:
     {{if 'cudaLaunchAttributeValue.memSyncDomain' in found_struct}}
     @property
     def memSyncDomain(self):
-        return cudaLaunchMemSyncDomain(self._pvt_ptr[0].memSyncDomain)
+        if self._pvt_ptr[0].memSyncDomain not in _dict_cudaLaunchMemSyncDomain:
+            return None
+        return _dict_cudaLaunchMemSyncDomain[self._pvt_ptr[0].memSyncDomain]
     @memSyncDomain.setter
     def memSyncDomain(self, memSyncDomain not None : cudaLaunchMemSyncDomain):
         self._pvt_ptr[0].memSyncDomain = memSyncDomain.value
@@ -16528,7 +16730,9 @@ cdef class cudaLaunchAttribute_st:
     {{if 'cudaLaunchAttribute_st.id' in found_struct}}
     @property
     def id(self):
-        return cudaLaunchAttributeID(self._pvt_ptr[0].id)
+        if self._pvt_ptr[0].id not in _dict_cudaLaunchAttributeID:
+            return None
+        return _dict_cudaLaunchAttributeID[self._pvt_ptr[0].id]
     @id.setter
     def id(self, id not None : cudaLaunchAttributeID):
         self._pvt_ptr[0].id = id.value
@@ -16696,7 +16900,9 @@ cdef class cudaAsyncNotificationInfo:
     {{if 'cudaAsyncNotificationInfo.type' in found_struct}}
     @property
     def type(self):
-        return cudaAsyncNotificationType(self._pvt_ptr[0].type)
+        if self._pvt_ptr[0].type not in _dict_cudaAsyncNotificationType:
+            return None
+        return _dict_cudaAsyncNotificationType[self._pvt_ptr[0].type]
     @type.setter
     def type(self, type not None : cudaAsyncNotificationType):
         self._pvt_ptr[0].type = type.value
@@ -16874,7 +17080,7 @@ cdef class cudaTextureDesc:
     {{if 'cudaTextureDesc.addressMode' in found_struct}}
     @property
     def addressMode(self):
-        return [cudaTextureAddressMode(_x) for _x in list(self._pvt_ptr[0].addressMode)]
+        return [_dict_cudaTextureAddressMode[_x] if _x in _dict_cudaTextureAddressMode else None for _x in list(self._pvt_ptr[0].addressMode)]
     @addressMode.setter
     def addressMode(self, addressMode):
         self._pvt_ptr[0].addressMode = [_x.value for _x in addressMode]
@@ -16882,7 +17088,9 @@ cdef class cudaTextureDesc:
     {{if 'cudaTextureDesc.filterMode' in found_struct}}
     @property
     def filterMode(self):
-        return cudaTextureFilterMode(self._pvt_ptr[0].filterMode)
+        if self._pvt_ptr[0].filterMode not in _dict_cudaTextureFilterMode:
+            return None
+        return _dict_cudaTextureFilterMode[self._pvt_ptr[0].filterMode]
     @filterMode.setter
     def filterMode(self, filterMode not None : cudaTextureFilterMode):
         self._pvt_ptr[0].filterMode = filterMode.value
@@ -16890,7 +17098,9 @@ cdef class cudaTextureDesc:
     {{if 'cudaTextureDesc.readMode' in found_struct}}
     @property
     def readMode(self):
-        return cudaTextureReadMode(self._pvt_ptr[0].readMode)
+        if self._pvt_ptr[0].readMode not in _dict_cudaTextureReadMode:
+            return None
+        return _dict_cudaTextureReadMode[self._pvt_ptr[0].readMode]
     @readMode.setter
     def readMode(self, readMode not None : cudaTextureReadMode):
         self._pvt_ptr[0].readMode = readMode.value
@@ -16930,7 +17140,9 @@ cdef class cudaTextureDesc:
     {{if 'cudaTextureDesc.mipmapFilterMode' in found_struct}}
     @property
     def mipmapFilterMode(self):
-        return cudaTextureFilterMode(self._pvt_ptr[0].mipmapFilterMode)
+        if self._pvt_ptr[0].mipmapFilterMode not in _dict_cudaTextureFilterMode:
+            return None
+        return _dict_cudaTextureFilterMode[self._pvt_ptr[0].mipmapFilterMode]
     @mipmapFilterMode.setter
     def mipmapFilterMode(self, mipmapFilterMode not None : cudaTextureFilterMode):
         self._pvt_ptr[0].mipmapFilterMode = mipmapFilterMode.value
@@ -17341,7 +17553,9 @@ cdef class cudaEglFrame_st:
     {{if True}}
     @property
     def frameType(self):
-        return cudaEglFrameType(self._pvt_ptr[0].frameType)
+        if self._pvt_ptr[0].frameType not in _dict_cudaEglFrameType:
+            return None
+        return _dict_cudaEglFrameType[self._pvt_ptr[0].frameType]
     @frameType.setter
     def frameType(self, frameType not None : cudaEglFrameType):
         self._pvt_ptr[0].frameType = frameType.value
@@ -17349,7 +17563,9 @@ cdef class cudaEglFrame_st:
     {{if True}}
     @property
     def eglColorFormat(self):
-        return cudaEglColorFormat(self._pvt_ptr[0].eglColorFormat)
+        if self._pvt_ptr[0].eglColorFormat not in _dict_cudaEglColorFormat:
+            return None
+        return _dict_cudaEglColorFormat[self._pvt_ptr[0].eglColorFormat]
     @eglColorFormat.setter
     def eglColorFormat(self, eglColorFormat not None : cudaEglColorFormat):
         self._pvt_ptr[0].eglColorFormat = eglColorFormat.value
@@ -17684,7 +17900,7 @@ def cudaDeviceReset():
     If a non-primary :py:obj:`~.CUcontext` is current to the thread, :py:obj:`~.cudaDeviceReset()` will destroy only the internal CUDA RT state for that :py:obj:`~.CUcontext`.
     """
     err = cyruntime.cudaDeviceReset()
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceSynchronize' in found_functions}}
@@ -17712,7 +17928,7 @@ def cudaDeviceSynchronize():
     with nogil:
         err = cyruntime.cudaDeviceSynchronize()
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceSetLimit' in found_functions}}
@@ -17814,7 +18030,7 @@ def cudaDeviceSetLimit(limit not None : cudaLimit, size_t value):
     """
     cdef cyruntime.cudaLimit cylimit = limit.value
     err = cyruntime.cudaDeviceSetLimit(cylimit, value)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceGetLimit' in found_functions}}
@@ -17871,7 +18087,7 @@ def cudaDeviceGetLimit(limit not None : cudaLimit):
     cdef size_t pValue = 0
     cdef cyruntime.cudaLimit cylimit = limit.value
     err = cyruntime.cudaDeviceGetLimit(&pValue, cylimit)
-    return (cudaError_t(err), pValue)
+    return (_dict_cudaError_t[err], pValue)
 {{endif}}
 
 {{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}
@@ -17906,7 +18122,7 @@ def cudaDeviceGetTexture1DLinearMaxWidth(fmtDesc : Optional[cudaChannelFormatDes
     cdef size_t maxWidthInElements = 0
     cdef cyruntime.cudaChannelFormatDesc* cyfmtDesc_ptr = fmtDesc._pvt_ptr if fmtDesc != None else NULL
     err = cyruntime.cudaDeviceGetTexture1DLinearMaxWidth(&maxWidthInElements, cyfmtDesc_ptr, device)
-    return (cudaError_t(err), maxWidthInElements)
+    return (_dict_cudaError_t[err], maxWidthInElements)
 {{endif}}
 
 {{if 'cudaDeviceGetCacheConfig' in found_functions}}
@@ -17953,7 +18169,7 @@ def cudaDeviceGetCacheConfig():
     """
     cdef cyruntime.cudaFuncCache pCacheConfig
     err = cyruntime.cudaDeviceGetCacheConfig(&pCacheConfig)
-    return (cudaError_t(err), cudaFuncCache(pCacheConfig))
+    return (_dict_cudaError_t[err], cudaFuncCache(pCacheConfig))
 {{endif}}
 
 {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}
@@ -17997,7 +18213,7 @@ def cudaDeviceGetStreamPriorityRange():
     cdef int leastPriority = 0
     cdef int greatestPriority = 0
     err = cyruntime.cudaDeviceGetStreamPriorityRange(&leastPriority, &greatestPriority)
-    return (cudaError_t(err), leastPriority, greatestPriority)
+    return (_dict_cudaError_t[err], leastPriority, greatestPriority)
 {{endif}}
 
 {{if 'cudaDeviceSetCacheConfig' in found_functions}}
@@ -18054,7 +18270,7 @@ def cudaDeviceSetCacheConfig(cacheConfig not None : cudaFuncCache):
     """
     cdef cyruntime.cudaFuncCache cycacheConfig = cacheConfig.value
     err = cyruntime.cudaDeviceSetCacheConfig(cycacheConfig)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceGetByPCIBusId' in found_functions}}
@@ -18086,7 +18302,7 @@ def cudaDeviceGetByPCIBusId(char* pciBusId):
     """
     cdef int device = 0
     err = cyruntime.cudaDeviceGetByPCIBusId(&device, pciBusId)
-    return (cudaError_t(err), device)
+    return (_dict_cudaError_t[err], device)
 {{endif}}
 
 {{if 'cudaDeviceGetPCIBusId' in found_functions}}
@@ -18124,7 +18340,7 @@ def cudaDeviceGetPCIBusId(int length, int device):
     pypciBusId = b" " * length
     cdef char* pciBusId = pypciBusId
     err = cyruntime.cudaDeviceGetPCIBusId(pciBusId, length, device)
-    return (cudaError_t(err), pypciBusId)
+    return (_dict_cudaError_t[err], pypciBusId)
 {{endif}}
 
 {{if 'cudaIpcGetEventHandle' in found_functions}}
@@ -18182,7 +18398,7 @@ def cudaIpcGetEventHandle(event):
     cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     cdef cudaIpcEventHandle_t handle = cudaIpcEventHandle_t()
     err = cyruntime.cudaIpcGetEventHandle(<cyruntime.cudaIpcEventHandle_t*>handle._pvt_ptr, cyevent)
-    return (cudaError_t(err), handle)
+    return (_dict_cudaError_t[err], handle)
 {{endif}}
 
 {{if 'cudaIpcOpenEventHandle' in found_functions}}
@@ -18226,7 +18442,7 @@ def cudaIpcOpenEventHandle(handle not None : cudaIpcEventHandle_t):
     """
     cdef cudaEvent_t event = cudaEvent_t()
     err = cyruntime.cudaIpcOpenEventHandle(<cyruntime.cudaEvent_t*>event._pvt_ptr, handle._pvt_ptr[0])
-    return (cudaError_t(err), event)
+    return (_dict_cudaError_t[err], event)
 {{endif}}
 
 {{if 'cudaIpcGetMemHandle' in found_functions}}
@@ -18273,7 +18489,7 @@ def cudaIpcGetMemHandle(devPtr):
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaIpcGetMemHandle(<cyruntime.cudaIpcMemHandle_t*>handle._pvt_ptr, cydevPtr_ptr)
-    return (cudaError_t(err), handle)
+    return (_dict_cudaError_t[err], handle)
 {{endif}}
 
 {{if 'cudaIpcOpenMemHandle' in found_functions}}
@@ -18343,7 +18559,7 @@ def cudaIpcOpenMemHandle(handle not None : cudaIpcMemHandle_t, unsigned int flag
     """
     cdef void_ptr devPtr = 0
     err = cyruntime.cudaIpcOpenMemHandle(<void**>&devPtr, handle._pvt_ptr[0], flags)
-    return (cudaError_t(err), devPtr)
+    return (_dict_cudaError_t[err], devPtr)
 {{endif}}
 
 {{if 'cudaIpcCloseMemHandle' in found_functions}}
@@ -18385,7 +18601,7 @@ def cudaIpcCloseMemHandle(devPtr):
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaIpcCloseMemHandle(cydevPtr_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}
@@ -18427,7 +18643,7 @@ def cudaDeviceFlushGPUDirectRDMAWrites(target not None : cudaFlushGPUDirectRDMAW
     cdef cyruntime.cudaFlushGPUDirectRDMAWritesTarget cytarget = target.value
     cdef cyruntime.cudaFlushGPUDirectRDMAWritesScope cyscope = scope.value
     err = cyruntime.cudaDeviceFlushGPUDirectRDMAWrites(cytarget, cyscope)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceRegisterAsyncNotification' in found_functions}}
@@ -18513,7 +18729,7 @@ def cudaDeviceRegisterAsyncNotification(int device, callbackFunc, userData):
         free(cbData)
     else:
         m_global._allocated[int(callback)] = cbData
-    return (cudaError_t(err), callback)
+    return (_dict_cudaError_t[err], callback)
 {{endif}}
 
 {{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}}
@@ -18554,7 +18770,7 @@ def cudaDeviceUnregisterAsyncNotification(int device, callback):
     if err == cyruntime.cudaSuccess:
         free(m_global._allocated[pcallback])
         m_global._allocated.erase(<void_ptr>pcallback)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceGetSharedMemConfig' in found_functions}}
@@ -18595,7 +18811,7 @@ def cudaDeviceGetSharedMemConfig():
     """
     cdef cyruntime.cudaSharedMemConfig pConfig
     err = cyruntime.cudaDeviceGetSharedMemConfig(&pConfig)
-    return (cudaError_t(err), cudaSharedMemConfig(pConfig))
+    return (_dict_cudaError_t[err], cudaSharedMemConfig(pConfig))
 {{endif}}
 
 {{if 'cudaDeviceSetSharedMemConfig' in found_functions}}
@@ -18651,7 +18867,7 @@ def cudaDeviceSetSharedMemConfig(config not None : cudaSharedMemConfig):
     """
     cdef cyruntime.cudaSharedMemConfig cyconfig = config.value
     err = cyruntime.cudaDeviceSetSharedMemConfig(cyconfig)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetLastError' in found_functions}}
@@ -18678,7 +18894,7 @@ def cudaGetLastError():
     :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaError`
     """
     err = cyruntime.cudaGetLastError()
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaPeekAtLastError' in found_functions}}
@@ -18706,7 +18922,7 @@ def cudaPeekAtLastError():
     :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaError`
     """
     err = cyruntime.cudaPeekAtLastError()
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetErrorName' in found_functions}}
@@ -18793,7 +19009,7 @@ def cudaGetDeviceCount():
     """
     cdef int count = 0
     err = cyruntime.cudaGetDeviceCount(&count)
-    return (cudaError_t(err), count)
+    return (_dict_cudaError_t[err], count)
 {{endif}}
 
 {{if 'cudaGetDeviceProperties_v2' in found_functions}}
@@ -19119,7 +19335,7 @@ def cudaGetDeviceProperties(int device):
     """
     cdef cudaDeviceProp prop = cudaDeviceProp()
     err = cyruntime.cudaGetDeviceProperties(<cyruntime.cudaDeviceProp*>prop._pvt_ptr, device)
-    return (cudaError_t(err), prop)
+    return (_dict_cudaError_t[err], prop)
 {{endif}}
 
 {{if 'cudaDeviceGetAttribute' in found_functions}}
@@ -19495,7 +19711,7 @@ def cudaDeviceGetAttribute(attr not None : cudaDeviceAttr, int device):
     cdef int value = 0
     cdef cyruntime.cudaDeviceAttr cyattr = attr.value
     err = cyruntime.cudaDeviceGetAttribute(&value, cyattr, device)
-    return (cudaError_t(err), value)
+    return (_dict_cudaError_t[err], value)
 {{endif}}
 
 {{if 'cudaDeviceGetDefaultMemPool' in found_functions}}
@@ -19527,7 +19743,7 @@ def cudaDeviceGetDefaultMemPool(int device):
     with nogil:
         err = cyruntime.cudaDeviceGetDefaultMemPool(<cyruntime.cudaMemPool_t*>memPool._pvt_ptr, device)
 
-    return (cudaError_t(err), memPool)
+    return (_dict_cudaError_t[err], memPool)
 {{endif}}
 
 {{if 'cudaDeviceSetMemPool' in found_functions}}
@@ -19573,7 +19789,7 @@ def cudaDeviceSetMemPool(int device, memPool):
     with nogil:
         err = cyruntime.cudaDeviceSetMemPool(device, cymemPool)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceGetMemPool' in found_functions}}
@@ -19609,7 +19825,7 @@ def cudaDeviceGetMemPool(int device):
     with nogil:
         err = cyruntime.cudaDeviceGetMemPool(<cyruntime.cudaMemPool_t*>memPool._pvt_ptr, device)
 
-    return (cudaError_t(err), memPool)
+    return (_dict_cudaError_t[err], memPool)
 {{endif}}
 
 {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}}
@@ -19694,7 +19910,7 @@ def cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, int device, int flags):
     cynvSciSyncAttrList = utils.HelperInputVoidPtr(nvSciSyncAttrList)
     cdef void* cynvSciSyncAttrList_ptr = <void*><void_ptr>cynvSciSyncAttrList.cptr
     err = cyruntime.cudaDeviceGetNvSciSyncAttributes(cynvSciSyncAttrList_ptr, device, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceGetP2PAttribute' in found_functions}}
@@ -19751,7 +19967,7 @@ def cudaDeviceGetP2PAttribute(attr not None : cudaDeviceP2PAttr, int srcDevice,
     cdef int value = 0
     cdef cyruntime.cudaDeviceP2PAttr cyattr = attr.value
     err = cyruntime.cudaDeviceGetP2PAttribute(&value, cyattr, srcDevice, dstDevice)
-    return (cudaError_t(err), value)
+    return (_dict_cudaError_t[err], value)
 {{endif}}
 
 {{if 'cudaChooseDevice' in found_functions}}
@@ -19782,7 +19998,7 @@ def cudaChooseDevice(prop : Optional[cudaDeviceProp]):
     cdef int device = 0
     cdef cyruntime.cudaDeviceProp* cyprop_ptr = prop._pvt_ptr if prop != None else NULL
     err = cyruntime.cudaChooseDevice(&device, cyprop_ptr)
-    return (cudaError_t(err), device)
+    return (_dict_cudaError_t[err], device)
 {{endif}}
 
 {{if 'cudaInitDevice' in found_functions}}
@@ -19824,7 +20040,7 @@ def cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags):
     :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cudaSetDevice` :py:obj:`~.cuCtxSetCurrent`
     """
     err = cyruntime.cudaInitDevice(device, deviceFlags, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaSetDevice' in found_functions}}
@@ -19879,7 +20095,7 @@ def cudaSetDevice(int device):
     :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cudaInitDevice`, :py:obj:`~.cuCtxSetCurrent`
     """
     err = cyruntime.cudaSetDevice(device)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetDevice' in found_functions}}
@@ -19904,7 +20120,7 @@ def cudaGetDevice():
     """
     cdef int device = 0
     err = cyruntime.cudaGetDevice(&device)
-    return (cudaError_t(err), device)
+    return (_dict_cudaError_t[err], device)
 {{endif}}
 
 {{if 'cudaSetDeviceFlags' in found_functions}}
@@ -19990,7 +20206,7 @@ def cudaSetDeviceFlags(unsigned int flags):
     :py:obj:`~.cudaGetDeviceFlags`, :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaSetValidDevices`, :py:obj:`~.cudaInitDevice`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cuDevicePrimaryCtxSetFlags`
     """
     err = cyruntime.cudaSetDeviceFlags(flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetDeviceFlags' in found_functions}}
@@ -20037,7 +20253,7 @@ def cudaGetDeviceFlags():
     """
     cdef unsigned int flags = 0
     err = cyruntime.cudaGetDeviceFlags(&flags)
-    return (cudaError_t(err), flags)
+    return (_dict_cudaError_t[err], flags)
 {{endif}}
 
 {{if 'cudaStreamCreate' in found_functions}}
@@ -20064,7 +20280,7 @@ def cudaStreamCreate():
     """
     cdef cudaStream_t pStream = cudaStream_t()
     err = cyruntime.cudaStreamCreate(<cyruntime.cudaStream_t*>pStream._pvt_ptr)
-    return (cudaError_t(err), pStream)
+    return (_dict_cudaError_t[err], pStream)
 {{endif}}
 
 {{if 'cudaStreamCreateWithFlags' in found_functions}}
@@ -20105,7 +20321,7 @@ def cudaStreamCreateWithFlags(unsigned int flags):
     """
     cdef cudaStream_t pStream = cudaStream_t()
     err = cyruntime.cudaStreamCreateWithFlags(<cyruntime.cudaStream_t*>pStream._pvt_ptr, flags)
-    return (cudaError_t(err), pStream)
+    return (_dict_cudaError_t[err], pStream)
 {{endif}}
 
 {{if 'cudaStreamCreateWithPriority' in found_functions}}
@@ -20163,7 +20379,7 @@ def cudaStreamCreateWithPriority(unsigned int flags, int priority):
     """
     cdef cudaStream_t pStream = cudaStream_t()
     err = cyruntime.cudaStreamCreateWithPriority(<cyruntime.cudaStream_t*>pStream._pvt_ptr, flags, priority)
-    return (cudaError_t(err), pStream)
+    return (_dict_cudaError_t[err], pStream)
 {{endif}}
 
 {{if 'cudaStreamGetPriority' in found_functions}}
@@ -20206,7 +20422,7 @@ def cudaStreamGetPriority(hStream):
     cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef int priority = 0
     err = cyruntime.cudaStreamGetPriority(cyhStream, &priority)
-    return (cudaError_t(err), priority)
+    return (_dict_cudaError_t[err], priority)
 {{endif}}
 
 {{if 'cudaStreamGetFlags' in found_functions}}
@@ -20245,7 +20461,7 @@ def cudaStreamGetFlags(hStream):
     cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef unsigned int flags = 0
     err = cyruntime.cudaStreamGetFlags(cyhStream, &flags)
-    return (cudaError_t(err), flags)
+    return (_dict_cudaError_t[err], flags)
 {{endif}}
 
 {{if 'cudaStreamGetId' in found_functions}}
@@ -20298,7 +20514,7 @@ def cudaStreamGetId(hStream):
     cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef unsigned long long streamId = 0
     err = cyruntime.cudaStreamGetId(cyhStream, &streamId)
-    return (cudaError_t(err), streamId)
+    return (_dict_cudaError_t[err], streamId)
 {{endif}}
 
 {{if 'cudaStreamGetDevice' in found_functions}}
@@ -20335,7 +20551,7 @@ def cudaStreamGetDevice(hStream):
     cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef int device = 0
     err = cyruntime.cudaStreamGetDevice(cyhStream, &device)
-    return (cudaError_t(err), device)
+    return (_dict_cudaError_t[err], device)
 {{endif}}
 
 {{if 'cudaCtxResetPersistingL2Cache' in found_functions}}
@@ -20357,7 +20573,7 @@ def cudaCtxResetPersistingL2Cache():
     :py:obj:`~.cudaAccessPolicyWindow`
     """
     err = cyruntime.cudaCtxResetPersistingL2Cache()
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamCopyAttributes' in found_functions}}
@@ -20402,7 +20618,7 @@ def cudaStreamCopyAttributes(dst, src):
         pdst = int(cudaStream_t(dst))
     cydst = <cyruntime.cudaStream_t><void_ptr>pdst
     err = cyruntime.cudaStreamCopyAttributes(cydst, cysrc)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamGetAttribute' in found_functions}}
@@ -20443,7 +20659,7 @@ def cudaStreamGetAttribute(hStream, attr not None : cudaStreamAttrID):
     cdef cyruntime.cudaStreamAttrID cyattr = attr.value
     cdef cudaStreamAttrValue value_out = cudaStreamAttrValue()
     err = cyruntime.cudaStreamGetAttribute(cyhStream, cyattr, <cyruntime.cudaStreamAttrValue*>value_out._pvt_ptr)
-    return (cudaError_t(err), value_out)
+    return (_dict_cudaError_t[err], value_out)
 {{endif}}
 
 {{if 'cudaStreamSetAttribute' in found_functions}}
@@ -20485,7 +20701,7 @@ def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Op
     cdef cyruntime.cudaStreamAttrID cyattr = attr.value
     cdef cyruntime.cudaStreamAttrValue* cyvalue_ptr = value._pvt_ptr if value != None else NULL
     err = cyruntime.cudaStreamSetAttribute(cyhStream, cyattr, cyvalue_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamDestroy' in found_functions}}
@@ -20524,7 +20740,7 @@ def cudaStreamDestroy(stream):
         pstream = int(cudaStream_t(stream))
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     err = cyruntime.cudaStreamDestroy(cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamWaitEvent' in found_functions}}
@@ -20583,7 +20799,7 @@ def cudaStreamWaitEvent(stream, event, unsigned int flags):
     with nogil:
         err = cyruntime.cudaStreamWaitEvent(cystream, cyevent, flags)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamAddCallback' in found_functions}}
@@ -20701,7 +20917,7 @@ def cudaStreamAddCallback(stream, callback, userData, unsigned int flags):
 
     if err != cyruntime.cudaSuccess:
         free(cbData)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamSynchronize' in found_functions}}
@@ -20740,7 +20956,7 @@ def cudaStreamSynchronize(stream):
     with nogil:
         err = cyruntime.cudaStreamSynchronize(cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamQuery' in found_functions}}
@@ -20779,7 +20995,7 @@ def cudaStreamQuery(stream):
         pstream = int(cudaStream_t(stream))
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     err = cyruntime.cudaStreamQuery(cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamAttachMemAsync' in found_functions}}
@@ -20889,7 +21105,7 @@ def cudaStreamAttachMemAsync(stream, devPtr, size_t length, unsigned int flags):
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaStreamAttachMemAsync(cystream, cydevPtr_ptr, length, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamBeginCapture' in found_functions}}
@@ -20945,7 +21161,7 @@ def cudaStreamBeginCapture(stream, mode not None : cudaStreamCaptureMode):
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     cdef cyruntime.cudaStreamCaptureMode cymode = mode.value
     err = cyruntime.cudaStreamBeginCapture(cystream, cymode)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamBeginCaptureToGraph' in found_functions}}
@@ -21045,7 +21261,7 @@ def cudaStreamBeginCaptureToGraph(stream, graph, dependencies : Optional[Tuple[c
         free(cydependencies)
     if cydependencyData is not NULL:
         free(cydependencyData)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}}
@@ -21116,7 +21332,7 @@ def cudaThreadExchangeStreamCaptureMode(mode not None : cudaStreamCaptureMode):
     """
     cdef cyruntime.cudaStreamCaptureMode cymode = mode.value
     err = cyruntime.cudaThreadExchangeStreamCaptureMode(&cymode)
-    return (cudaError_t(err), cudaStreamCaptureMode(cymode))
+    return (_dict_cudaError_t[err], cudaStreamCaptureMode(cymode))
 {{endif}}
 
 {{if 'cudaStreamEndCapture' in found_functions}}
@@ -21161,7 +21377,7 @@ def cudaStreamEndCapture(stream):
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     cdef cudaGraph_t pGraph = cudaGraph_t()
     err = cyruntime.cudaStreamEndCapture(cystream, <cyruntime.cudaGraph_t*>pGraph._pvt_ptr)
-    return (cudaError_t(err), pGraph)
+    return (_dict_cudaError_t[err], pGraph)
 {{endif}}
 
 {{if 'cudaStreamIsCapturing' in found_functions}}
@@ -21220,7 +21436,7 @@ def cudaStreamIsCapturing(stream):
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     cdef cyruntime.cudaStreamCaptureStatus pCaptureStatus
     err = cyruntime.cudaStreamIsCapturing(cystream, &pCaptureStatus)
-    return (cudaError_t(err), cudaStreamCaptureStatus(pCaptureStatus))
+    return (_dict_cudaError_t[err], cudaStreamCaptureStatus(pCaptureStatus))
 {{endif}}
 
 {{if 'cudaStreamGetCaptureInfo_v2' in found_functions}}
@@ -21301,7 +21517,7 @@ def cudaStreamGetCaptureInfo(stream):
     err = cyruntime.cudaStreamGetCaptureInfo(cystream, &captureStatus_out, &id_out, <cyruntime.cudaGraph_t*>graph_out._pvt_ptr, &cydependencies_out, &numDependencies_out)
     if cudaError_t(err) == cudaError_t(0):
         pydependencies_out = [cudaGraphNode_t(init_value=<void_ptr>cydependencies_out[idx]) for idx in range(numDependencies_out)]
-    return (cudaError_t(err), cudaStreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, numDependencies_out)
+    return (_dict_cudaError_t[err], cudaStreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, numDependencies_out)
 {{endif}}
 
 {{if 'cudaStreamGetCaptureInfo_v3' in found_functions}}
@@ -21398,7 +21614,7 @@ def cudaStreamGetCaptureInfo_v3(stream):
         pydependencies_out = [cudaGraphNode_t(init_value=<void_ptr>cydependencies_out[idx]) for idx in range(numDependencies_out)]
     if cudaError_t(err) == cudaError_t(0):
         pyedgeData_out = [cudaGraphEdgeData(_ptr=<void_ptr>&cyedgeData_out[idx]) for idx in range(numDependencies_out)]
-    return (cudaError_t(err), cudaStreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, pyedgeData_out, numDependencies_out)
+    return (_dict_cudaError_t[err], cudaStreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, pyedgeData_out, numDependencies_out)
 {{endif}}
 
 {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}}
@@ -21471,7 +21687,7 @@ def cudaStreamUpdateCaptureDependencies(stream, dependencies : Optional[Tuple[cu
     err = cyruntime.cudaStreamUpdateCaptureDependencies(cystream, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>dependencies[0])._pvt_ptr if len(dependencies) == 1 else cydependencies, numDependencies, flags)
     if cydependencies is not NULL:
         free(cydependencies)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}}
@@ -21553,7 +21769,7 @@ def cudaStreamUpdateCaptureDependencies_v2(stream, dependencies : Optional[Tuple
         free(cydependencies)
     if cydependencyData is not NULL:
         free(cydependencyData)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaEventCreate' in found_functions}}
@@ -21578,7 +21794,7 @@ def cudaEventCreate():
     """
     cdef cudaEvent_t event = cudaEvent_t()
     err = cyruntime.cudaEventCreate(<cyruntime.cudaEvent_t*>event._pvt_ptr)
-    return (cudaError_t(err), event)
+    return (_dict_cudaError_t[err], event)
 {{endif}}
 
 {{if 'cudaEventCreateWithFlags' in found_functions}}
@@ -21627,7 +21843,7 @@ def cudaEventCreateWithFlags(unsigned int flags):
     """
     cdef cudaEvent_t event = cudaEvent_t()
     err = cyruntime.cudaEventCreateWithFlags(<cyruntime.cudaEvent_t*>event._pvt_ptr, flags)
-    return (cudaError_t(err), event)
+    return (_dict_cudaError_t[err], event)
 {{endif}}
 
 {{if 'cudaEventRecord' in found_functions}}
@@ -21685,7 +21901,7 @@ def cudaEventRecord(event, stream):
         pevent = int(cudaEvent_t(event))
     cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     err = cyruntime.cudaEventRecord(cyevent, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaEventRecordWithFlags' in found_functions}}
@@ -21752,7 +21968,7 @@ def cudaEventRecordWithFlags(event, stream, unsigned int flags):
         pevent = int(cudaEvent_t(event))
     cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     err = cyruntime.cudaEventRecordWithFlags(cyevent, cystream, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaEventQuery' in found_functions}}
@@ -21796,7 +22012,7 @@ def cudaEventQuery(event):
         pevent = int(cudaEvent_t(event))
     cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     err = cyruntime.cudaEventQuery(cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaEventSynchronize' in found_functions}}
@@ -21839,7 +22055,7 @@ def cudaEventSynchronize(event):
         pevent = int(cudaEvent_t(event))
     cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     err = cyruntime.cudaEventSynchronize(cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaEventDestroy' in found_functions}}
@@ -21879,7 +22095,7 @@ def cudaEventDestroy(event):
         pevent = int(cudaEvent_t(event))
     cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     err = cyruntime.cudaEventDestroy(cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaEventElapsedTime' in found_functions}}
@@ -21945,7 +22161,7 @@ def cudaEventElapsedTime(start, end):
     cystart = <cyruntime.cudaEvent_t><void_ptr>pstart
     cdef float ms = 0
     err = cyruntime.cudaEventElapsedTime(&ms, cystart, cyend)
-    return (cudaError_t(err), ms)
+    return (_dict_cudaError_t[err], ms)
 {{endif}}
 
 {{if 'cudaEventElapsedTime_v2' in found_functions}}
@@ -22015,7 +22231,7 @@ def cudaEventElapsedTime_v2(start, end):
     cystart = <cyruntime.cudaEvent_t><void_ptr>pstart
     cdef float ms = 0
     err = cyruntime.cudaEventElapsedTime_v2(&ms, cystart, cyend)
-    return (cudaError_t(err), ms)
+    return (_dict_cudaError_t[err], ms)
 {{endif}}
 
 {{if 'cudaImportExternalMemory' in found_functions}}
@@ -22166,7 +22382,7 @@ def cudaImportExternalMemory(memHandleDesc : Optional[cudaExternalMemoryHandleDe
     cdef cudaExternalMemory_t extMem_out = cudaExternalMemory_t()
     cdef cyruntime.cudaExternalMemoryHandleDesc* cymemHandleDesc_ptr = memHandleDesc._pvt_ptr if memHandleDesc != None else NULL
     err = cyruntime.cudaImportExternalMemory(<cyruntime.cudaExternalMemory_t*>extMem_out._pvt_ptr, cymemHandleDesc_ptr)
-    return (cudaError_t(err), extMem_out)
+    return (_dict_cudaError_t[err], extMem_out)
 {{endif}}
 
 {{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}}
@@ -22231,7 +22447,7 @@ def cudaExternalMemoryGetMappedBuffer(extMem, bufferDesc : Optional[cudaExternal
     cdef void_ptr devPtr = 0
     cdef cyruntime.cudaExternalMemoryBufferDesc* cybufferDesc_ptr = bufferDesc._pvt_ptr if bufferDesc != None else NULL
     err = cyruntime.cudaExternalMemoryGetMappedBuffer(<void**>&devPtr, cyextMem, cybufferDesc_ptr)
-    return (cudaError_t(err), devPtr)
+    return (_dict_cudaError_t[err], devPtr)
 {{endif}}
 
 {{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}}
@@ -22300,7 +22516,7 @@ def cudaExternalMemoryGetMappedMipmappedArray(extMem, mipmapDesc : Optional[cuda
     cdef cudaMipmappedArray_t mipmap = cudaMipmappedArray_t()
     cdef cyruntime.cudaExternalMemoryMipmappedArrayDesc* cymipmapDesc_ptr = mipmapDesc._pvt_ptr if mipmapDesc != None else NULL
     err = cyruntime.cudaExternalMemoryGetMappedMipmappedArray(<cyruntime.cudaMipmappedArray_t*>mipmap._pvt_ptr, cyextMem, cymipmapDesc_ptr)
-    return (cudaError_t(err), mipmap)
+    return (_dict_cudaError_t[err], mipmap)
 {{endif}}
 
 {{if 'cudaDestroyExternalMemory' in found_functions}}
@@ -22337,7 +22553,7 @@ def cudaDestroyExternalMemory(extMem):
         pextMem = int(cudaExternalMemory_t(extMem))
     cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
     err = cyruntime.cudaDestroyExternalMemory(cyextMem)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaImportExternalSemaphore' in found_functions}}
@@ -22483,7 +22699,7 @@ def cudaImportExternalSemaphore(semHandleDesc : Optional[cudaExternalSemaphoreHa
     cdef cudaExternalSemaphore_t extSem_out = cudaExternalSemaphore_t()
     cdef cyruntime.cudaExternalSemaphoreHandleDesc* cysemHandleDesc_ptr = semHandleDesc._pvt_ptr if semHandleDesc != None else NULL
     err = cyruntime.cudaImportExternalSemaphore(<cyruntime.cudaExternalSemaphore_t*>extSem_out._pvt_ptr, cysemHandleDesc_ptr)
-    return (cudaError_t(err), extSem_out)
+    return (_dict_cudaError_t[err], extSem_out)
 {{endif}}
 
 {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}
@@ -22618,7 +22834,7 @@ def cudaSignalExternalSemaphoresAsync(extSemArray : Optional[Tuple[cudaExternalS
         free(cyextSemArray)
     if cyparamsArray is not NULL:
         free(cyparamsArray)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}
@@ -22742,7 +22958,7 @@ def cudaWaitExternalSemaphoresAsync(extSemArray : Optional[Tuple[cudaExternalSem
         free(cyextSemArray)
     if cyparamsArray is not NULL:
         free(cyparamsArray)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDestroyExternalSemaphore' in found_functions}}
@@ -22778,7 +22994,7 @@ def cudaDestroyExternalSemaphore(extSem):
         pextSem = int(cudaExternalSemaphore_t(extSem))
     cyextSem = <cyruntime.cudaExternalSemaphore_t><void_ptr>pextSem
     err = cyruntime.cudaDestroyExternalSemaphore(cyextSem)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaFuncSetCacheConfig' in found_functions}}
@@ -22844,7 +23060,7 @@ def cudaFuncSetCacheConfig(func, cacheConfig not None : cudaFuncCache):
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     cdef cyruntime.cudaFuncCache cycacheConfig = cacheConfig.value
     err = cyruntime.cudaFuncSetCacheConfig(cyfunc_ptr, cycacheConfig)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaFuncGetAttributes' in found_functions}}
@@ -22885,7 +23101,7 @@ def cudaFuncGetAttributes(func):
     cyfunc = utils.HelperInputVoidPtr(func)
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     err = cyruntime.cudaFuncGetAttributes(<cyruntime.cudaFuncAttributes*>attr._pvt_ptr, cyfunc_ptr)
-    return (cudaError_t(err), attr)
+    return (_dict_cudaError_t[err], attr)
 {{endif}}
 
 {{if 'cudaFuncSetAttribute' in found_functions}}
@@ -22970,7 +23186,7 @@ def cudaFuncSetAttribute(func, attr not None : cudaFuncAttribute, int value):
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     cdef cyruntime.cudaFuncAttribute cyattr = attr.value
     err = cyruntime.cudaFuncSetAttribute(cyfunc_ptr, cyattr, value)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaLaunchHostFunc' in found_functions}}
@@ -23081,7 +23297,7 @@ def cudaLaunchHostFunc(stream, fn, userData):
 
     if err != cyruntime.cudaSuccess:
         free(cbData)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaFuncSetSharedMemConfig' in found_functions}}
@@ -23148,7 +23364,7 @@ def cudaFuncSetSharedMemConfig(func, config not None : cudaSharedMemConfig):
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     cdef cyruntime.cudaSharedMemConfig cyconfig = config.value
     err = cyruntime.cudaFuncSetSharedMemConfig(cyfunc_ptr, cyconfig)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}
@@ -23184,7 +23400,7 @@ def cudaOccupancyMaxActiveBlocksPerMultiprocessor(func, int blockSize, size_t dy
     cyfunc = utils.HelperInputVoidPtr(func)
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     err = cyruntime.cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, cyfunc_ptr, blockSize, dynamicSMemSize)
-    return (cudaError_t(err), numBlocks)
+    return (_dict_cudaError_t[err], numBlocks)
 {{endif}}
 
 {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}}
@@ -23220,7 +23436,7 @@ def cudaOccupancyAvailableDynamicSMemPerBlock(func, int numBlocks, int blockSize
     cyfunc = utils.HelperInputVoidPtr(func)
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     err = cyruntime.cudaOccupancyAvailableDynamicSMemPerBlock(&dynamicSmemSize, cyfunc_ptr, numBlocks, blockSize)
-    return (cudaError_t(err), dynamicSmemSize)
+    return (_dict_cudaError_t[err], dynamicSmemSize)
 {{endif}}
 
 {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}
@@ -23273,7 +23489,7 @@ def cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(func, int blockSize,
     cyfunc = utils.HelperInputVoidPtr(func)
     cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
     err = cyruntime.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlocks, cyfunc_ptr, blockSize, dynamicSMemSize, flags)
-    return (cudaError_t(err), numBlocks)
+    return (_dict_cudaError_t[err], numBlocks)
 {{endif}}
 
 {{if 'cudaMallocManaged' in found_functions}}
@@ -23406,7 +23622,7 @@ def cudaMallocManaged(size_t size, unsigned int flags):
     with nogil:
         err = cyruntime.cudaMallocManaged(<void**>&devPtr, size, flags)
 
-    return (cudaError_t(err), devPtr)
+    return (_dict_cudaError_t[err], devPtr)
 {{endif}}
 
 {{if 'cudaMalloc' in found_functions}}
@@ -23444,7 +23660,7 @@ def cudaMalloc(size_t size):
     with nogil:
         err = cyruntime.cudaMalloc(<void**>&devPtr, size)
 
-    return (cudaError_t(err), devPtr)
+    return (_dict_cudaError_t[err], devPtr)
 {{endif}}
 
 {{if 'cudaMallocHost' in found_functions}}
@@ -23489,7 +23705,7 @@ def cudaMallocHost(size_t size):
     """
     cdef void_ptr ptr = 0
     err = cyruntime.cudaMallocHost(<void**>&ptr, size)
-    return (cudaError_t(err), ptr)
+    return (_dict_cudaError_t[err], ptr)
 {{endif}}
 
 {{if 'cudaMallocPitch' in found_functions}}
@@ -23542,7 +23758,7 @@ def cudaMallocPitch(size_t width, size_t height):
     cdef void_ptr devPtr = 0
     cdef size_t pitch = 0
     err = cyruntime.cudaMallocPitch(<void**>&devPtr, &pitch, width, height)
-    return (cudaError_t(err), devPtr, pitch)
+    return (_dict_cudaError_t[err], devPtr, pitch)
 {{endif}}
 
 {{if 'cudaMallocArray' in found_functions}}
@@ -23618,7 +23834,7 @@ def cudaMallocArray(desc : Optional[cudaChannelFormatDesc], size_t width, size_t
     with nogil:
         err = cyruntime.cudaMallocArray(<cyruntime.cudaArray_t*>array._pvt_ptr, cydesc_ptr, width, height, flags)
 
-    return (cudaError_t(err), array)
+    return (_dict_cudaError_t[err], array)
 {{endif}}
 
 {{if 'cudaFree' in found_functions}}
@@ -23669,7 +23885,7 @@ def cudaFree(devPtr):
     with nogil:
         err = cyruntime.cudaFree(cydevPtr_ptr)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaFreeHost' in found_functions}}
@@ -23701,7 +23917,7 @@ def cudaFreeHost(ptr):
     with nogil:
         err = cyruntime.cudaFreeHost(cyptr_ptr)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaFreeArray' in found_functions}}
@@ -23739,7 +23955,7 @@ def cudaFreeArray(array):
     with nogil:
         err = cyruntime.cudaFreeArray(cyarray)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaFreeMipmappedArray' in found_functions}}
@@ -23775,7 +23991,7 @@ def cudaFreeMipmappedArray(mipmappedArray):
         pmipmappedArray = int(cudaMipmappedArray_t(mipmappedArray))
     cymipmappedArray = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmappedArray
     err = cyruntime.cudaFreeMipmappedArray(cymipmappedArray)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaHostAlloc' in found_functions}}
@@ -23859,7 +24075,7 @@ def cudaHostAlloc(size_t size, unsigned int flags):
     with nogil:
         err = cyruntime.cudaHostAlloc(<void**>&pHost, size, flags)
 
-    return (cudaError_t(err), pHost)
+    return (_dict_cudaError_t[err], pHost)
 {{endif}}
 
 {{if 'cudaHostRegister' in found_functions}}
@@ -23977,7 +24193,7 @@ def cudaHostRegister(ptr, size_t size, unsigned int flags):
     with nogil:
         err = cyruntime.cudaHostRegister(cyptr_ptr, size, flags)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaHostUnregister' in found_functions}}
@@ -24011,7 +24227,7 @@ def cudaHostUnregister(ptr):
     with nogil:
         err = cyruntime.cudaHostUnregister(cyptr_ptr)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaHostGetDevicePointer' in found_functions}}
@@ -24070,7 +24286,7 @@ def cudaHostGetDevicePointer(pHost, unsigned int flags):
     cypHost = utils.HelperInputVoidPtr(pHost)
     cdef void* cypHost_ptr = <void*><void_ptr>cypHost.cptr
     err = cyruntime.cudaHostGetDevicePointer(<void**>&pDevice, cypHost_ptr, flags)
-    return (cudaError_t(err), pDevice)
+    return (_dict_cudaError_t[err], pDevice)
 {{endif}}
 
 {{if 'cudaHostGetFlags' in found_functions}}
@@ -24102,7 +24318,7 @@ def cudaHostGetFlags(pHost):
     cypHost = utils.HelperInputVoidPtr(pHost)
     cdef void* cypHost_ptr = <void*><void_ptr>cypHost.cptr
     err = cyruntime.cudaHostGetFlags(&pFlags, cypHost_ptr)
-    return (cudaError_t(err), pFlags)
+    return (_dict_cudaError_t[err], pFlags)
 {{endif}}
 
 {{if 'cudaMalloc3D' in found_functions}}
@@ -24148,7 +24364,7 @@ def cudaMalloc3D(extent not None : cudaExtent):
     """
     cdef cudaPitchedPtr pitchedDevPtr = cudaPitchedPtr()
     err = cyruntime.cudaMalloc3D(<cyruntime.cudaPitchedPtr*>pitchedDevPtr._pvt_ptr, extent._pvt_ptr[0])
-    return (cudaError_t(err), pitchedDevPtr)
+    return (_dict_cudaError_t[err], pitchedDevPtr)
 {{endif}}
 
 {{if 'cudaMalloc3DArray' in found_functions}}
@@ -24270,7 +24486,7 @@ def cudaMalloc3DArray(desc : Optional[cudaChannelFormatDesc], extent not None :
     with nogil:
         err = cyruntime.cudaMalloc3DArray(<cyruntime.cudaArray_t*>array._pvt_ptr, cydesc_ptr, extent._pvt_ptr[0], flags)
 
-    return (cudaError_t(err), array)
+    return (_dict_cudaError_t[err], array)
 {{endif}}
 
 {{if 'cudaMallocMipmappedArray' in found_functions}}
@@ -24393,7 +24609,7 @@ def cudaMallocMipmappedArray(desc : Optional[cudaChannelFormatDesc], extent not
     cdef cudaMipmappedArray_t mipmappedArray = cudaMipmappedArray_t()
     cdef cyruntime.cudaChannelFormatDesc* cydesc_ptr = desc._pvt_ptr if desc != None else NULL
     err = cyruntime.cudaMallocMipmappedArray(<cyruntime.cudaMipmappedArray_t*>mipmappedArray._pvt_ptr, cydesc_ptr, extent._pvt_ptr[0], numLevels, flags)
-    return (cudaError_t(err), mipmappedArray)
+    return (_dict_cudaError_t[err], mipmappedArray)
 {{endif}}
 
 {{if 'cudaGetMipmappedArrayLevel' in found_functions}}
@@ -24439,7 +24655,7 @@ def cudaGetMipmappedArrayLevel(mipmappedArray, unsigned int level):
     cymipmappedArray = <cyruntime.cudaMipmappedArray_const_t><void_ptr>pmipmappedArray
     cdef cudaArray_t levelArray = cudaArray_t()
     err = cyruntime.cudaGetMipmappedArrayLevel(<cyruntime.cudaArray_t*>levelArray._pvt_ptr, cymipmappedArray, level)
-    return (cudaError_t(err), levelArray)
+    return (_dict_cudaError_t[err], levelArray)
 {{endif}}
 
 {{if 'cudaMemcpy3D' in found_functions}}
@@ -24524,7 +24740,7 @@ def cudaMemcpy3D(p : Optional[cudaMemcpy3DParms]):
     with nogil:
         err = cyruntime.cudaMemcpy3D(cyp_ptr)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy3DPeer' in found_functions}}
@@ -24560,7 +24776,7 @@ def cudaMemcpy3DPeer(p : Optional[cudaMemcpy3DPeerParms]):
     """
     cdef cyruntime.cudaMemcpy3DPeerParms* cyp_ptr = p._pvt_ptr if p != None else NULL
     err = cyruntime.cudaMemcpy3DPeer(cyp_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy3DAsync' in found_functions}}
@@ -24666,7 +24882,7 @@ def cudaMemcpy3DAsync(p : Optional[cudaMemcpy3DParms], stream):
     with nogil:
         err = cyruntime.cudaMemcpy3DAsync(cyp_ptr, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy3DPeerAsync' in found_functions}}
@@ -24705,7 +24921,7 @@ def cudaMemcpy3DPeerAsync(p : Optional[cudaMemcpy3DPeerParms], stream):
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     cdef cyruntime.cudaMemcpy3DPeerParms* cyp_ptr = p._pvt_ptr if p != None else NULL
     err = cyruntime.cudaMemcpy3DPeerAsync(cyp_ptr, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemGetInfo' in found_functions}}
@@ -24747,7 +24963,7 @@ def cudaMemGetInfo():
     cdef size_t free = 0
     cdef size_t total = 0
     err = cyruntime.cudaMemGetInfo(&free, &total)
-    return (cudaError_t(err), free, total)
+    return (_dict_cudaError_t[err], free, total)
 {{endif}}
 
 {{if 'cudaArrayGetInfo' in found_functions}}
@@ -24793,7 +25009,7 @@ def cudaArrayGetInfo(array):
     cdef cudaExtent extent = cudaExtent()
     cdef unsigned int flags = 0
     err = cyruntime.cudaArrayGetInfo(<cyruntime.cudaChannelFormatDesc*>desc._pvt_ptr, <cyruntime.cudaExtent*>extent._pvt_ptr, &flags, cyarray)
-    return (cudaError_t(err), desc, extent, flags)
+    return (_dict_cudaError_t[err], desc, extent, flags)
 {{endif}}
 
 {{if 'cudaArrayGetPlane' in found_functions}}
@@ -24846,7 +25062,7 @@ def cudaArrayGetPlane(hArray, unsigned int planeIdx):
     cyhArray = <cyruntime.cudaArray_t><void_ptr>phArray
     cdef cudaArray_t pPlaneArray = cudaArray_t()
     err = cyruntime.cudaArrayGetPlane(<cyruntime.cudaArray_t*>pPlaneArray._pvt_ptr, cyhArray, planeIdx)
-    return (cudaError_t(err), pPlaneArray)
+    return (_dict_cudaError_t[err], pPlaneArray)
 {{endif}}
 
 {{if 'cudaArrayGetMemoryRequirements' in found_functions}}
@@ -24893,7 +25109,7 @@ def cudaArrayGetMemoryRequirements(array, int device):
     cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     cdef cudaArrayMemoryRequirements memoryRequirements = cudaArrayMemoryRequirements()
     err = cyruntime.cudaArrayGetMemoryRequirements(<cyruntime.cudaArrayMemoryRequirements*>memoryRequirements._pvt_ptr, cyarray, device)
-    return (cudaError_t(err), memoryRequirements)
+    return (_dict_cudaError_t[err], memoryRequirements)
 {{endif}}
 
 {{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}}
@@ -24940,7 +25156,7 @@ def cudaMipmappedArrayGetMemoryRequirements(mipmap, int device):
     cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
     cdef cudaArrayMemoryRequirements memoryRequirements = cudaArrayMemoryRequirements()
     err = cyruntime.cudaMipmappedArrayGetMemoryRequirements(<cyruntime.cudaArrayMemoryRequirements*>memoryRequirements._pvt_ptr, cymipmap, device)
-    return (cudaError_t(err), memoryRequirements)
+    return (_dict_cudaError_t[err], memoryRequirements)
 {{endif}}
 
 {{if 'cudaArrayGetSparseProperties' in found_functions}}
@@ -24993,7 +25209,7 @@ def cudaArrayGetSparseProperties(array):
     cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     cdef cudaArraySparseProperties sparseProperties = cudaArraySparseProperties()
     err = cyruntime.cudaArrayGetSparseProperties(<cyruntime.cudaArraySparseProperties*>sparseProperties._pvt_ptr, cyarray)
-    return (cudaError_t(err), sparseProperties)
+    return (_dict_cudaError_t[err], sparseProperties)
 {{endif}}
 
 {{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}}
@@ -25046,7 +25262,7 @@ def cudaMipmappedArrayGetSparseProperties(mipmap):
     cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
     cdef cudaArraySparseProperties sparseProperties = cudaArraySparseProperties()
     err = cyruntime.cudaMipmappedArrayGetSparseProperties(<cyruntime.cudaArraySparseProperties*>sparseProperties._pvt_ptr, cymipmap)
-    return (cudaError_t(err), sparseProperties)
+    return (_dict_cudaError_t[err], sparseProperties)
 {{endif}}
 
 {{if 'cudaMemcpy' in found_functions}}
@@ -25097,7 +25313,7 @@ def cudaMemcpy(dst, src, size_t count, kind not None : cudaMemcpyKind):
     with nogil:
         err = cyruntime.cudaMemcpy(cydst_ptr, cysrc_ptr, count, cykind)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyPeer' in found_functions}}
@@ -25146,7 +25362,7 @@ def cudaMemcpyPeer(dst, int dstDevice, src, int srcDevice, size_t count):
     with nogil:
         err = cyruntime.cudaMemcpyPeer(cydst_ptr, dstDevice, cysrc_ptr, srcDevice, count)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy2D' in found_functions}}
@@ -25207,7 +25423,7 @@ def cudaMemcpy2D(dst, size_t dpitch, src, size_t spitch, size_t width, size_t he
     with nogil:
         err = cyruntime.cudaMemcpy2D(cydst_ptr, dpitch, cysrc_ptr, spitch, width, height, cykind)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy2DToArray' in found_functions}}
@@ -25275,7 +25491,7 @@ def cudaMemcpy2DToArray(dst, size_t wOffset, size_t hOffset, src, size_t spitch,
     with nogil:
         err = cyruntime.cudaMemcpy2DToArray(cydst, wOffset, hOffset, cysrc_ptr, spitch, width, height, cykind)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy2DFromArray' in found_functions}}
@@ -25343,7 +25559,7 @@ def cudaMemcpy2DFromArray(dst, size_t dpitch, src, size_t wOffset, size_t hOffse
     with nogil:
         err = cyruntime.cudaMemcpy2DFromArray(cydst_ptr, dpitch, cysrc, wOffset, hOffset, width, height, cykind)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy2DArrayToArray' in found_functions}}
@@ -25415,7 +25631,7 @@ def cudaMemcpy2DArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, siz
     cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaMemcpy2DArrayToArray(cydst, wOffsetDst, hOffsetDst, cysrc, wOffsetSrc, hOffsetSrc, width, height, cykind)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyAsync' in found_functions}}
@@ -25486,7 +25702,7 @@ def cudaMemcpyAsync(dst, src, size_t count, kind not None : cudaMemcpyKind, stre
     with nogil:
         err = cyruntime.cudaMemcpyAsync(cydst_ptr, cysrc_ptr, count, cykind, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyPeerAsync' in found_functions}}
@@ -25543,7 +25759,7 @@ def cudaMemcpyPeerAsync(dst, int dstDevice, src, int srcDevice, size_t count, st
     with nogil:
         err = cyruntime.cudaMemcpyPeerAsync(cydst_ptr, dstDevice, cysrc_ptr, srcDevice, count, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyBatchAsync' in found_functions}}
@@ -25697,7 +25913,7 @@ def cudaMemcpyBatchAsync(dsts : Optional[Tuple[Any] | List[Any]], srcs : Optiona
     err = cyruntime.cudaMemcpyBatchAsync(<void**><void_ptr>voidStarHelperdsts.cptr, <void**><void_ptr>voidStarHelpersrcs.cptr, cysizes.data(), count, (<cudaMemcpyAttributes>attrs[0])._pvt_ptr if len(attrs) == 1 else cyattrs, cyattrsIdxs.data(), numAttrs, &failIdx, cystream)
     if cyattrs is not NULL:
         free(cyattrs)
-    return (cudaError_t(err), failIdx)
+    return (_dict_cudaError_t[err], failIdx)
 {{endif}}
 
 {{if 'cudaMemcpy3DBatchAsync' in found_functions}}
@@ -25833,7 +26049,7 @@ def cudaMemcpy3DBatchAsync(size_t numOps, opList : Optional[Tuple[cudaMemcpy3DBa
     err = cyruntime.cudaMemcpy3DBatchAsync(numOps, (<cudaMemcpy3DBatchOp>opList[0])._pvt_ptr if len(opList) == 1 else cyopList, &failIdx, flags, cystream)
     if cyopList is not NULL:
         free(cyopList)
-    return (cudaError_t(err), failIdx)
+    return (_dict_cudaError_t[err], failIdx)
 {{endif}}
 
 {{if 'cudaMemcpy2DAsync' in found_functions}}
@@ -25915,7 +26131,7 @@ def cudaMemcpy2DAsync(dst, size_t dpitch, src, size_t spitch, size_t width, size
     with nogil:
         err = cyruntime.cudaMemcpy2DAsync(cydst_ptr, dpitch, cysrc_ptr, spitch, width, height, cykind, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy2DToArrayAsync' in found_functions}}
@@ -26004,7 +26220,7 @@ def cudaMemcpy2DToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t sp
     with nogil:
         err = cyruntime.cudaMemcpy2DToArrayAsync(cydst, wOffset, hOffset, cysrc_ptr, spitch, width, height, cykind, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpy2DFromArrayAsync' in found_functions}}
@@ -26092,7 +26308,7 @@ def cudaMemcpy2DFromArrayAsync(dst, size_t dpitch, src, size_t wOffset, size_t h
     with nogil:
         err = cyruntime.cudaMemcpy2DFromArrayAsync(cydst_ptr, dpitch, cysrc, wOffset, hOffset, width, height, cykind, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemset' in found_functions}}
@@ -26130,7 +26346,7 @@ def cudaMemset(devPtr, int value, size_t count):
     with nogil:
         err = cyruntime.cudaMemset(cydevPtr_ptr, value, count)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemset2D' in found_functions}}
@@ -26173,7 +26389,7 @@ def cudaMemset2D(devPtr, size_t pitch, int value, size_t width, size_t height):
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaMemset2D(cydevPtr_ptr, pitch, value, width, height)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemset3D' in found_functions}}
@@ -26226,7 +26442,7 @@ def cudaMemset3D(pitchedDevPtr not None : cudaPitchedPtr, int value, extent not
     :py:obj:`~.cudaMemset`, :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaMemsetAsync`, :py:obj:`~.cudaMemset2DAsync`, :py:obj:`~.cudaMemset3DAsync`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.make_cudaPitchedPtr`, :py:obj:`~.make_cudaExtent`
     """
     err = cyruntime.cudaMemset3D(pitchedDevPtr._pvt_ptr[0], value, extent._pvt_ptr[0])
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemsetAsync' in found_functions}}
@@ -26280,7 +26496,7 @@ def cudaMemsetAsync(devPtr, int value, size_t count, stream):
     with nogil:
         err = cyruntime.cudaMemsetAsync(cydevPtr_ptr, value, count, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemset2DAsync' in found_functions}}
@@ -26339,7 +26555,7 @@ def cudaMemset2DAsync(devPtr, size_t pitch, int value, size_t width, size_t heig
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaMemset2DAsync(cydevPtr_ptr, pitch, value, width, height, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemset3DAsync' in found_functions}}
@@ -26408,7 +26624,7 @@ def cudaMemset3DAsync(pitchedDevPtr not None : cudaPitchedPtr, int value, extent
         pstream = int(cudaStream_t(stream))
     cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     err = cyruntime.cudaMemset3DAsync(pitchedDevPtr._pvt_ptr[0], value, extent._pvt_ptr[0], cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemPrefetchAsync' in found_functions}}
@@ -26508,7 +26724,7 @@ def cudaMemPrefetchAsync(devPtr, size_t count, int dstDevice, stream):
     with nogil:
         err = cyruntime.cudaMemPrefetchAsync(cydevPtr_ptr, count, dstDevice, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemPrefetchAsync_v2' in found_functions}}
@@ -26626,7 +26842,7 @@ def cudaMemPrefetchAsync_v2(devPtr, size_t count, location not None : cudaMemLoc
     with nogil:
         err = cyruntime.cudaMemPrefetchAsync_v2(cydevPtr_ptr, count, location._pvt_ptr[0], flags, cystream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemAdvise' in found_functions}}
@@ -26793,7 +27009,7 @@ def cudaMemAdvise(devPtr, size_t count, advice not None : cudaMemoryAdvise, int
     with nogil:
         err = cyruntime.cudaMemAdvise(cydevPtr_ptr, count, cyadvice, device)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemAdvise_v2' in found_functions}}
@@ -26991,7 +27207,7 @@ def cudaMemAdvise_v2(devPtr, size_t count, advice not None : cudaMemoryAdvise, l
     with nogil:
         err = cyruntime.cudaMemAdvise_v2(cydevPtr_ptr, count, cyadvice, location._pvt_ptr[0])
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemRangeGetAttribute' in found_functions}}
@@ -27139,7 +27355,7 @@ def cudaMemRangeGetAttribute(size_t dataSize, attribute not None : cudaMemRangeA
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaMemRangeGetAttribute(cydata_ptr, dataSize, cyattribute, cydevPtr_ptr, count)
-    return (cudaError_t(err), cydata.pyObj())
+    return (_dict_cudaError_t[err], cydata.pyObj())
 {{endif}}
 
 {{if 'cudaMemRangeGetAttributes' in found_functions}}
@@ -27217,7 +27433,7 @@ def cudaMemRangeGetAttributes(dataSizes : Tuple[int] | List[int], attributes : O
     cydevPtr = utils.HelperInputVoidPtr(devPtr)
     cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     err = cyruntime.cudaMemRangeGetAttributes(cyvoidStarHelper_ptr, cydataSizes.data(), cyattributes.data(), numAttributes, cydevPtr_ptr, count)
-    return (cudaError_t(err), [obj.pyObj() for obj in pylist])
+    return (_dict_cudaError_t[err], [obj.pyObj() for obj in pylist])
 {{endif}}
 
 {{if 'cudaMemcpyToArray' in found_functions}}
@@ -27275,7 +27491,7 @@ def cudaMemcpyToArray(dst, size_t wOffset, size_t hOffset, src, size_t count, ki
     cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaMemcpyToArray(cydst, wOffset, hOffset, cysrc_ptr, count, cykind)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyFromArray' in found_functions}}
@@ -27333,7 +27549,7 @@ def cudaMemcpyFromArray(dst, src, size_t wOffset, size_t hOffset, size_t count,
     cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaMemcpyFromArray(cydst_ptr, cysrc, wOffset, hOffset, count, cykind)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyArrayToArray' in found_functions}}
@@ -27402,7 +27618,7 @@ def cudaMemcpyArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, size_
     cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaMemcpyArrayToArray(cydst, wOffsetDst, hOffsetDst, cysrc, wOffsetSrc, hOffsetSrc, count, cykind)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyToArrayAsync' in found_functions}}
@@ -27477,7 +27693,7 @@ def cudaMemcpyToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t coun
     cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaMemcpyToArrayAsync(cydst, wOffset, hOffset, cysrc_ptr, count, cykind, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemcpyFromArrayAsync' in found_functions}}
@@ -27552,7 +27768,7 @@ def cudaMemcpyFromArrayAsync(dst, src, size_t wOffset, size_t hOffset, size_t co
     cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaMemcpyFromArrayAsync(cydst_ptr, cysrc, wOffset, hOffset, count, cykind, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMallocAsync' in found_functions}}
@@ -27606,7 +27822,7 @@ def cudaMallocAsync(size_t size, hStream):
     with nogil:
         err = cyruntime.cudaMallocAsync(<void**>&devPtr, size, cyhStream)
 
-    return (cudaError_t(err), devPtr)
+    return (_dict_cudaError_t[err], devPtr)
 {{endif}}
 
 {{if 'cudaFreeAsync' in found_functions}}
@@ -27653,7 +27869,7 @@ def cudaFreeAsync(devPtr, hStream):
     with nogil:
         err = cyruntime.cudaFreeAsync(cydevPtr_ptr, cyhStream)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemPoolTrimTo' in found_functions}}
@@ -27704,7 +27920,7 @@ def cudaMemPoolTrimTo(memPool, size_t minBytesToKeep):
     with nogil:
         err = cyruntime.cudaMemPoolTrimTo(cymemPool, minBytesToKeep)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemPoolSetAttribute' in found_functions}}
@@ -27781,7 +27997,7 @@ def cudaMemPoolSetAttribute(memPool, attr not None : cudaMemPoolAttr, value):
     with nogil:
         err = cyruntime.cudaMemPoolSetAttribute(cymemPool, cyattr, cyvalue_ptr)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemPoolGetAttribute' in found_functions}}
@@ -27864,7 +28080,7 @@ def cudaMemPoolGetAttribute(memPool, attr not None : cudaMemPoolAttr):
     with nogil:
         err = cyruntime.cudaMemPoolGetAttribute(cymemPool, cyattr, cyvalue_ptr)
 
-    return (cudaError_t(err), cyvalue.pyObj())
+    return (_dict_cudaError_t[err], cyvalue.pyObj())
 {{endif}}
 
 {{if 'cudaMemPoolSetAccess' in found_functions}}
@@ -27914,7 +28130,7 @@ def cudaMemPoolSetAccess(memPool, descList : Optional[Tuple[cudaMemAccessDesc] |
     err = cyruntime.cudaMemPoolSetAccess(cymemPool, (<cudaMemAccessDesc>descList[0])._pvt_ptr if len(descList) == 1 else cydescList, count)
     if cydescList is not NULL:
         free(cydescList)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMemPoolGetAccess' in found_functions}}
@@ -27955,7 +28171,7 @@ def cudaMemPoolGetAccess(memPool, location : Optional[cudaMemLocation]):
     cdef cyruntime.cudaMemAccessFlags flags
     cdef cyruntime.cudaMemLocation* cylocation_ptr = location._pvt_ptr if location != None else NULL
     err = cyruntime.cudaMemPoolGetAccess(&flags, cymemPool, cylocation_ptr)
-    return (cudaError_t(err), cudaMemAccessFlags(flags))
+    return (_dict_cudaError_t[err], cudaMemAccessFlags(flags))
 {{endif}}
 
 {{if 'cudaMemPoolCreate' in found_functions}}
@@ -28028,7 +28244,7 @@ def cudaMemPoolCreate(poolProps : Optional[cudaMemPoolProps]):
     cdef cudaMemPool_t memPool = cudaMemPool_t()
     cdef cyruntime.cudaMemPoolProps* cypoolProps_ptr = poolProps._pvt_ptr if poolProps != None else NULL
     err = cyruntime.cudaMemPoolCreate(<cyruntime.cudaMemPool_t*>memPool._pvt_ptr, cypoolProps_ptr)
-    return (cudaError_t(err), memPool)
+    return (_dict_cudaError_t[err], memPool)
 {{endif}}
 
 {{if 'cudaMemPoolDestroy' in found_functions}}
@@ -28073,7 +28289,7 @@ def cudaMemPoolDestroy(memPool):
         pmemPool = int(cudaMemPool_t(memPool))
     cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     err = cyruntime.cudaMemPoolDestroy(cymemPool)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaMallocFromPoolAsync' in found_functions}}
@@ -28129,7 +28345,7 @@ def cudaMallocFromPoolAsync(size_t size, memPool, stream):
     cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     cdef void_ptr ptr = 0
     err = cyruntime.cudaMallocFromPoolAsync(<void**>&ptr, size, cymemPool, cystream)
-    return (cudaError_t(err), ptr)
+    return (_dict_cudaError_t[err], ptr)
 {{endif}}
 
 {{if 'cudaMemPoolExportToShareableHandle' in found_functions}}
@@ -28183,7 +28399,7 @@ def cudaMemPoolExportToShareableHandle(memPool, handleType not None : cudaMemAll
     cdef void* cyshareableHandle_ptr = <void*><void_ptr>cyshareableHandle.cptr
     cdef cyruntime.cudaMemAllocationHandleType cyhandleType = handleType.value
     err = cyruntime.cudaMemPoolExportToShareableHandle(cyshareableHandle_ptr, cymemPool, cyhandleType, flags)
-    return (cudaError_t(err), cyshareableHandle.pyObj())
+    return (_dict_cudaError_t[err], cyshareableHandle.pyObj())
 {{endif}}
 
 {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}}
@@ -28224,7 +28440,7 @@ def cudaMemPoolImportFromShareableHandle(shareableHandle, handleType not None :
     cdef void* cyshareableHandle_ptr = <void*><void_ptr>cyshareableHandle.cptr
     cdef cyruntime.cudaMemAllocationHandleType cyhandleType = handleType.value
     err = cyruntime.cudaMemPoolImportFromShareableHandle(<cyruntime.cudaMemPool_t*>memPool._pvt_ptr, cyshareableHandle_ptr, cyhandleType, flags)
-    return (cudaError_t(err), memPool)
+    return (_dict_cudaError_t[err], memPool)
 {{endif}}
 
 {{if 'cudaMemPoolExportPointer' in found_functions}}
@@ -28258,7 +28474,7 @@ def cudaMemPoolExportPointer(ptr):
     cyptr = utils.HelperInputVoidPtr(ptr)
     cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     err = cyruntime.cudaMemPoolExportPointer(<cyruntime.cudaMemPoolPtrExportData*>exportData._pvt_ptr, cyptr_ptr)
-    return (cudaError_t(err), exportData)
+    return (_dict_cudaError_t[err], exportData)
 {{endif}}
 
 {{if 'cudaMemPoolImportPointer' in found_functions}}
@@ -28308,7 +28524,7 @@ def cudaMemPoolImportPointer(memPool, exportData : Optional[cudaMemPoolPtrExport
     cdef void_ptr ptr = 0
     cdef cyruntime.cudaMemPoolPtrExportData* cyexportData_ptr = exportData._pvt_ptr if exportData != None else NULL
     err = cyruntime.cudaMemPoolImportPointer(<void**>&ptr, cymemPool, cyexportData_ptr)
-    return (cudaError_t(err), ptr)
+    return (_dict_cudaError_t[err], ptr)
 {{endif}}
 
 {{if 'cudaPointerGetAttributes' in found_functions}}
@@ -28377,7 +28593,7 @@ def cudaPointerGetAttributes(ptr):
     cyptr = utils.HelperInputVoidPtr(ptr)
     cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     err = cyruntime.cudaPointerGetAttributes(<cyruntime.cudaPointerAttributes*>attributes._pvt_ptr, cyptr_ptr)
-    return (cudaError_t(err), attributes)
+    return (_dict_cudaError_t[err], attributes)
 {{endif}}
 
 {{if 'cudaDeviceCanAccessPeer' in found_functions}}
@@ -28413,7 +28629,7 @@ def cudaDeviceCanAccessPeer(int device, int peerDevice):
     """
     cdef int canAccessPeer = 0
     err = cyruntime.cudaDeviceCanAccessPeer(&canAccessPeer, device, peerDevice)
-    return (cudaError_t(err), canAccessPeer)
+    return (_dict_cudaError_t[err], canAccessPeer)
 {{endif}}
 
 {{if 'cudaDeviceEnablePeerAccess' in found_functions}}
@@ -28463,7 +28679,7 @@ def cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags):
     :py:obj:`~.cudaDeviceCanAccessPeer`, :py:obj:`~.cudaDeviceDisablePeerAccess`, :py:obj:`~.cuCtxEnablePeerAccess`
     """
     err = cyruntime.cudaDeviceEnablePeerAccess(peerDevice, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceDisablePeerAccess' in found_functions}}
@@ -28491,7 +28707,7 @@ def cudaDeviceDisablePeerAccess(int peerDevice):
     :py:obj:`~.cudaDeviceCanAccessPeer`, :py:obj:`~.cudaDeviceEnablePeerAccess`, :py:obj:`~.cuCtxDisablePeerAccess`
     """
     err = cyruntime.cudaDeviceDisablePeerAccess(peerDevice)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphicsUnregisterResource' in found_functions}}
@@ -28529,7 +28745,7 @@ def cudaGraphicsUnregisterResource(resource):
         presource = int(cudaGraphicsResource_t(resource))
     cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     err = cyruntime.cudaGraphicsUnregisterResource(cyresource)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}}
@@ -28584,7 +28800,7 @@ def cudaGraphicsResourceSetMapFlags(resource, unsigned int flags):
         presource = int(cudaGraphicsResource_t(resource))
     cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     err = cyruntime.cudaGraphicsResourceSetMapFlags(cyresource, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphicsMapResources' in found_functions}}
@@ -28646,7 +28862,7 @@ def cudaGraphicsMapResources(int count, resources, stream):
     else:
         raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, runtime.cudaGraphicsResource_t'>, found " + str(type(resources)))
     err = cyruntime.cudaGraphicsMapResources(count, cyresources, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphicsUnmapResources' in found_functions}}
@@ -28706,7 +28922,7 @@ def cudaGraphicsUnmapResources(int count, resources, stream):
     else:
         raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, runtime.cudaGraphicsResource_t'>, found " + str(type(resources)))
     err = cyruntime.cudaGraphicsUnmapResources(count, cyresources, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}}
@@ -28749,7 +28965,7 @@ def cudaGraphicsResourceGetMappedPointer(resource):
     cdef void_ptr devPtr = 0
     cdef size_t size = 0
     err = cyruntime.cudaGraphicsResourceGetMappedPointer(<void**>&devPtr, &size, cyresource)
-    return (cudaError_t(err), devPtr, size)
+    return (_dict_cudaError_t[err], devPtr, size)
 {{endif}}
 
 {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}}
@@ -28803,7 +29019,7 @@ def cudaGraphicsSubResourceGetMappedArray(resource, unsigned int arrayIndex, uns
     cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     cdef cudaArray_t array = cudaArray_t()
     err = cyruntime.cudaGraphicsSubResourceGetMappedArray(<cyruntime.cudaArray_t*>array._pvt_ptr, cyresource, arrayIndex, mipLevel)
-    return (cudaError_t(err), array)
+    return (_dict_cudaError_t[err], array)
 {{endif}}
 
 {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}}
@@ -28846,7 +29062,7 @@ def cudaGraphicsResourceGetMappedMipmappedArray(resource):
     cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     cdef cudaMipmappedArray_t mipmappedArray = cudaMipmappedArray_t()
     err = cyruntime.cudaGraphicsResourceGetMappedMipmappedArray(<cyruntime.cudaMipmappedArray_t*>mipmappedArray._pvt_ptr, cyresource)
-    return (cudaError_t(err), mipmappedArray)
+    return (_dict_cudaError_t[err], mipmappedArray)
 {{endif}}
 
 {{if 'cudaGetChannelDesc' in found_functions}}
@@ -28885,7 +29101,7 @@ def cudaGetChannelDesc(array):
     with nogil:
         err = cyruntime.cudaGetChannelDesc(<cyruntime.cudaChannelFormatDesc*>desc._pvt_ptr, cyarray)
 
-    return (cudaError_t(err), desc)
+    return (_dict_cudaError_t[err], desc)
 {{endif}}
 
 {{if 'cudaCreateChannelDesc' in found_functions}}
@@ -29175,7 +29391,7 @@ def cudaCreateTextureObject(pResDesc : Optional[cudaResourceDesc], pTexDesc : Op
     cdef cyruntime.cudaTextureDesc* cypTexDesc_ptr = pTexDesc._pvt_ptr if pTexDesc != None else NULL
     cdef cyruntime.cudaResourceViewDesc* cypResViewDesc_ptr = pResViewDesc._pvt_ptr if pResViewDesc != None else NULL
     err = cyruntime.cudaCreateTextureObject(<cyruntime.cudaTextureObject_t*>pTexObject._pvt_ptr, cypResDesc_ptr, cypTexDesc_ptr, cypResViewDesc_ptr)
-    return (cudaError_t(err), pTexObject)
+    return (_dict_cudaError_t[err], pTexObject)
 {{endif}}
 
 {{if 'cudaDestroyTextureObject' in found_functions}}
@@ -29211,7 +29427,7 @@ def cudaDestroyTextureObject(texObject):
     with nogil:
         err = cyruntime.cudaDestroyTextureObject(cytexObject)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetTextureObjectResourceDesc' in found_functions}}
@@ -29251,7 +29467,7 @@ def cudaGetTextureObjectResourceDesc(texObject):
     with nogil:
         err = cyruntime.cudaGetTextureObjectResourceDesc(<cyruntime.cudaResourceDesc*>pResDesc._pvt_ptr, cytexObject)
 
-    return (cudaError_t(err), pResDesc)
+    return (_dict_cudaError_t[err], pResDesc)
 {{endif}}
 
 {{if 'cudaGetTextureObjectTextureDesc' in found_functions}}
@@ -29291,7 +29507,7 @@ def cudaGetTextureObjectTextureDesc(texObject):
     with nogil:
         err = cyruntime.cudaGetTextureObjectTextureDesc(<cyruntime.cudaTextureDesc*>pTexDesc._pvt_ptr, cytexObject)
 
-    return (cudaError_t(err), pTexDesc)
+    return (_dict_cudaError_t[err], pTexDesc)
 {{endif}}
 
 {{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}
@@ -29330,7 +29546,7 @@ def cudaGetTextureObjectResourceViewDesc(texObject):
     cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
     cdef cudaResourceViewDesc pResViewDesc = cudaResourceViewDesc()
     err = cyruntime.cudaGetTextureObjectResourceViewDesc(<cyruntime.cudaResourceViewDesc*>pResViewDesc._pvt_ptr, cytexObject)
-    return (cudaError_t(err), pResViewDesc)
+    return (_dict_cudaError_t[err], pResViewDesc)
 {{endif}}
 
 {{if 'cudaCreateSurfaceObject' in found_functions}}
@@ -29371,7 +29587,7 @@ def cudaCreateSurfaceObject(pResDesc : Optional[cudaResourceDesc]):
     with nogil:
         err = cyruntime.cudaCreateSurfaceObject(<cyruntime.cudaSurfaceObject_t*>pSurfObject._pvt_ptr, cypResDesc_ptr)
 
-    return (cudaError_t(err), pSurfObject)
+    return (_dict_cudaError_t[err], pSurfObject)
 {{endif}}
 
 {{if 'cudaDestroySurfaceObject' in found_functions}}
@@ -29407,7 +29623,7 @@ def cudaDestroySurfaceObject(surfObject):
     with nogil:
         err = cyruntime.cudaDestroySurfaceObject(cysurfObject)
 
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}
@@ -29442,7 +29658,7 @@ def cudaGetSurfaceObjectResourceDesc(surfObject):
     cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>psurfObject
     cdef cudaResourceDesc pResDesc = cudaResourceDesc()
     err = cyruntime.cudaGetSurfaceObjectResourceDesc(<cyruntime.cudaResourceDesc*>pResDesc._pvt_ptr, cysurfObject)
-    return (cudaError_t(err), pResDesc)
+    return (_dict_cudaError_t[err], pResDesc)
 {{endif}}
 
 {{if 'cudaDriverGetVersion' in found_functions}}
@@ -29472,7 +29688,7 @@ def cudaDriverGetVersion():
     """
     cdef int driverVersion = 0
     err = cyruntime.cudaDriverGetVersion(&driverVersion)
-    return (cudaError_t(err), driverVersion)
+    return (_dict_cudaError_t[err], driverVersion)
 {{endif}}
 
 {{if 'cudaRuntimeGetVersion' in found_functions}}
@@ -29505,7 +29721,7 @@ def cudaRuntimeGetVersion():
     """
     cdef int runtimeVersion = 0
     err = cyruntime.cudaRuntimeGetVersion(&runtimeVersion)
-    return (cudaError_t(err), runtimeVersion)
+    return (_dict_cudaError_t[err], runtimeVersion)
 {{endif}}
 
 {{if 'cudaGraphCreate' in found_functions}}
@@ -29534,7 +29750,7 @@ def cudaGraphCreate(unsigned int flags):
     """
     cdef cudaGraph_t pGraph = cudaGraph_t()
     err = cyruntime.cudaGraphCreate(<cyruntime.cudaGraph_t*>pGraph._pvt_ptr, flags)
-    return (cudaError_t(err), pGraph)
+    return (_dict_cudaError_t[err], pGraph)
 {{endif}}
 
 {{if 'cudaGraphAddKernelNode' in found_functions}}
@@ -29651,7 +29867,7 @@ def cudaGraphAddKernelNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t
     err = cyruntime.cudaGraphAddKernelNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypNodeParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphKernelNodeGetParams' in found_functions}}
@@ -29697,7 +29913,7 @@ def cudaGraphKernelNodeGetParams(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaKernelNodeParams pNodeParams = cudaKernelNodeParams()
     err = cyruntime.cudaGraphKernelNodeGetParams(cynode, <cyruntime.cudaKernelNodeParams*>pNodeParams._pvt_ptr)
-    return (cudaError_t(err), pNodeParams)
+    return (_dict_cudaError_t[err], pNodeParams)
 {{endif}}
 
 {{if 'cudaGraphKernelNodeSetParams' in found_functions}}
@@ -29734,7 +29950,7 @@ def cudaGraphKernelNodeSetParams(node, pNodeParams : Optional[cudaKernelNodePara
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cyruntime.cudaKernelNodeParams* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphKernelNodeSetParams(cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}
@@ -29780,7 +29996,7 @@ def cudaGraphKernelNodeCopyAttributes(hSrc, hDst):
         phSrc = int(cudaGraphNode_t(hSrc))
     cyhSrc = <cyruntime.cudaGraphNode_t><void_ptr>phSrc
     err = cyruntime.cudaGraphKernelNodeCopyAttributes(cyhSrc, cyhDst)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}
@@ -29821,7 +30037,7 @@ def cudaGraphKernelNodeGetAttribute(hNode, attr not None : cudaKernelNodeAttrID)
     cdef cyruntime.cudaKernelNodeAttrID cyattr = attr.value
     cdef cudaKernelNodeAttrValue value_out = cudaKernelNodeAttrValue()
     err = cyruntime.cudaGraphKernelNodeGetAttribute(cyhNode, cyattr, <cyruntime.cudaKernelNodeAttrValue*>value_out._pvt_ptr)
-    return (cudaError_t(err), value_out)
+    return (_dict_cudaError_t[err], value_out)
 {{endif}}
 
 {{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}
@@ -29862,7 +30078,7 @@ def cudaGraphKernelNodeSetAttribute(hNode, attr not None : cudaKernelNodeAttrID,
     cdef cyruntime.cudaKernelNodeAttrID cyattr = attr.value
     cdef cyruntime.cudaKernelNodeAttrValue* cyvalue_ptr = value._pvt_ptr if value != None else NULL
     err = cyruntime.cudaGraphKernelNodeSetAttribute(cyhNode, cyattr, cyvalue_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddMemcpyNode' in found_functions}}
@@ -29933,7 +30149,7 @@ def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t
     err = cyruntime.cudaGraphAddMemcpyNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypCopyParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphAddMemcpyNode1D' in found_functions}}
@@ -30023,7 +30239,7 @@ def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[Tuple[cudaGraphNode
     err = cyruntime.cudaGraphAddMemcpyNode1D(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cydst_ptr, cysrc_ptr, count, cykind)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}
@@ -30060,7 +30276,7 @@ def cudaGraphMemcpyNodeGetParams(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaMemcpy3DParms pNodeParams = cudaMemcpy3DParms()
     err = cyruntime.cudaGraphMemcpyNodeGetParams(cynode, <cyruntime.cudaMemcpy3DParms*>pNodeParams._pvt_ptr)
-    return (cudaError_t(err), pNodeParams)
+    return (_dict_cudaError_t[err], pNodeParams)
 {{endif}}
 
 {{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}
@@ -30097,7 +30313,7 @@ def cudaGraphMemcpyNodeSetParams(node, pNodeParams : Optional[cudaMemcpy3DParms]
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cyruntime.cudaMemcpy3DParms* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphMemcpyNodeSetParams(cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}
@@ -30158,7 +30374,7 @@ def cudaGraphMemcpyNodeSetParams1D(node, dst, src, size_t count, kind not None :
     cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaGraphMemcpyNodeSetParams1D(cynode, cydst_ptr, cysrc_ptr, count, cykind)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddMemsetNode' in found_functions}}
@@ -30223,7 +30439,7 @@ def cudaGraphAddMemsetNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t
     err = cyruntime.cudaGraphAddMemsetNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypMemsetParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphMemsetNodeGetParams' in found_functions}}
@@ -30260,7 +30476,7 @@ def cudaGraphMemsetNodeGetParams(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaMemsetParams pNodeParams = cudaMemsetParams()
     err = cyruntime.cudaGraphMemsetNodeGetParams(cynode, <cyruntime.cudaMemsetParams*>pNodeParams._pvt_ptr)
-    return (cudaError_t(err), pNodeParams)
+    return (_dict_cudaError_t[err], pNodeParams)
 {{endif}}
 
 {{if 'cudaGraphMemsetNodeSetParams' in found_functions}}
@@ -30297,7 +30513,7 @@ def cudaGraphMemsetNodeSetParams(node, pNodeParams : Optional[cudaMemsetParams])
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cyruntime.cudaMemsetParams* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphMemsetNodeSetParams(cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddHostNode' in found_functions}}
@@ -30363,7 +30579,7 @@ def cudaGraphAddHostNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t]
     err = cyruntime.cudaGraphAddHostNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypNodeParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphHostNodeGetParams' in found_functions}}
@@ -30400,7 +30616,7 @@ def cudaGraphHostNodeGetParams(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaHostNodeParams pNodeParams = cudaHostNodeParams()
     err = cyruntime.cudaGraphHostNodeGetParams(cynode, <cyruntime.cudaHostNodeParams*>pNodeParams._pvt_ptr)
-    return (cudaError_t(err), pNodeParams)
+    return (_dict_cudaError_t[err], pNodeParams)
 {{endif}}
 
 {{if 'cudaGraphHostNodeSetParams' in found_functions}}
@@ -30437,7 +30653,7 @@ def cudaGraphHostNodeSetParams(node, pNodeParams : Optional[cudaHostNodeParams])
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cyruntime.cudaHostNodeParams* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphHostNodeSetParams(cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddChildGraphNode' in found_functions}}
@@ -30513,7 +30729,7 @@ def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[Tuple[cudaGraphNo
     err = cyruntime.cudaGraphAddChildGraphNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cychildGraph)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}
@@ -30555,7 +30771,7 @@ def cudaGraphChildGraphNodeGetGraph(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaGraph_t pGraph = cudaGraph_t()
     err = cyruntime.cudaGraphChildGraphNodeGetGraph(cynode, <cyruntime.cudaGraph_t*>pGraph._pvt_ptr)
-    return (cudaError_t(err), pGraph)
+    return (_dict_cudaError_t[err], pGraph)
 {{endif}}
 
 {{if 'cudaGraphAddEmptyNode' in found_functions}}
@@ -30621,7 +30837,7 @@ def cudaGraphAddEmptyNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t]
     err = cyruntime.cudaGraphAddEmptyNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphAddEventRecordNode' in found_functions}}
@@ -30696,7 +30912,7 @@ def cudaGraphAddEventRecordNode(graph, pDependencies : Optional[Tuple[cudaGraphN
     err = cyruntime.cudaGraphAddEventRecordNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cyevent)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}
@@ -30733,7 +30949,7 @@ def cudaGraphEventRecordNodeGetEvent(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaEvent_t event_out = cudaEvent_t()
     err = cyruntime.cudaGraphEventRecordNodeGetEvent(cynode, <cyruntime.cudaEvent_t*>event_out._pvt_ptr)
-    return (cudaError_t(err), event_out)
+    return (_dict_cudaError_t[err], event_out)
 {{endif}}
 
 {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}
@@ -30777,7 +30993,7 @@ def cudaGraphEventRecordNodeSetEvent(node, event):
         pnode = int(cudaGraphNode_t(node))
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     err = cyruntime.cudaGraphEventRecordNodeSetEvent(cynode, cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddEventWaitNode' in found_functions}}
@@ -30855,7 +31071,7 @@ def cudaGraphAddEventWaitNode(graph, pDependencies : Optional[Tuple[cudaGraphNod
     err = cyruntime.cudaGraphAddEventWaitNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cyevent)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}
@@ -30892,7 +31108,7 @@ def cudaGraphEventWaitNodeGetEvent(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaEvent_t event_out = cudaEvent_t()
     err = cyruntime.cudaGraphEventWaitNodeGetEvent(cynode, <cyruntime.cudaEvent_t*>event_out._pvt_ptr)
-    return (cudaError_t(err), event_out)
+    return (_dict_cudaError_t[err], event_out)
 {{endif}}
 
 {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}
@@ -30936,7 +31152,7 @@ def cudaGraphEventWaitNodeSetEvent(node, event):
         pnode = int(cudaGraphNode_t(node))
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     err = cyruntime.cudaGraphEventWaitNodeSetEvent(cynode, cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}
@@ -31003,7 +31219,7 @@ def cudaGraphAddExternalSemaphoresSignalNode(graph, pDependencies : Optional[Tup
     err = cyruntime.cudaGraphAddExternalSemaphoresSignalNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
@@ -31046,7 +31262,7 @@ def cudaGraphExternalSemaphoresSignalNodeGetParams(hNode):
     cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     cdef cudaExternalSemaphoreSignalNodeParams params_out = cudaExternalSemaphoreSignalNodeParams()
     err = cyruntime.cudaGraphExternalSemaphoresSignalNodeGetParams(cyhNode, <cyruntime.cudaExternalSemaphoreSignalNodeParams*>params_out._pvt_ptr)
-    return (cudaError_t(err), params_out)
+    return (_dict_cudaError_t[err], params_out)
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
@@ -31084,7 +31300,7 @@ def cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[
     cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cyruntime.cudaGraphExternalSemaphoresSignalNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}
@@ -31151,7 +31367,7 @@ def cudaGraphAddExternalSemaphoresWaitNode(graph, pDependencies : Optional[Tuple
     err = cyruntime.cudaGraphAddExternalSemaphoresWaitNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
@@ -31194,7 +31410,7 @@ def cudaGraphExternalSemaphoresWaitNodeGetParams(hNode):
     cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     cdef cudaExternalSemaphoreWaitNodeParams params_out = cudaExternalSemaphoreWaitNodeParams()
     err = cyruntime.cudaGraphExternalSemaphoresWaitNodeGetParams(cyhNode, <cyruntime.cudaExternalSemaphoreWaitNodeParams*>params_out._pvt_ptr)
-    return (cudaError_t(err), params_out)
+    return (_dict_cudaError_t[err], params_out)
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
@@ -31232,7 +31448,7 @@ def cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[cu
     cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cyruntime.cudaGraphExternalSemaphoresWaitNodeSetParams(cyhNode, cynodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddMemAllocNode' in found_functions}}
@@ -31337,7 +31553,7 @@ def cudaGraphAddMemAllocNode(graph, pDependencies : Optional[Tuple[cudaGraphNode
     err = cyruntime.cudaGraphAddMemAllocNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}
@@ -31377,7 +31593,7 @@ def cudaGraphMemAllocNodeGetParams(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cudaMemAllocNodeParams params_out = cudaMemAllocNodeParams()
     err = cyruntime.cudaGraphMemAllocNodeGetParams(cynode, <cyruntime.cudaMemAllocNodeParams*>params_out._pvt_ptr)
-    return (cudaError_t(err), params_out)
+    return (_dict_cudaError_t[err], params_out)
 {{endif}}
 
 {{if 'cudaGraphAddMemFreeNode' in found_functions}}
@@ -31461,7 +31677,7 @@ def cudaGraphAddMemFreeNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_
     err = cyruntime.cudaGraphAddMemFreeNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cydptr_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}
@@ -31499,7 +31715,7 @@ def cudaGraphMemFreeNodeGetParams(node):
     cdef void_ptr dptr_out = 0
     cdef void* cydptr_out_ptr = <void*>&dptr_out
     err = cyruntime.cudaGraphMemFreeNodeGetParams(cynode, cydptr_out_ptr)
-    return (cudaError_t(err), dptr_out)
+    return (_dict_cudaError_t[err], dptr_out)
 {{endif}}
 
 {{if 'cudaDeviceGraphMemTrim' in found_functions}}
@@ -31527,7 +31743,7 @@ def cudaDeviceGraphMemTrim(int device):
     :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`
     """
     err = cyruntime.cudaDeviceGraphMemTrim(device)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}
@@ -31575,7 +31791,7 @@ def cudaDeviceGetGraphMemAttribute(int device, attr not None : cudaGraphMemAttri
     cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, 0, is_getter=True)
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     err = cyruntime.cudaDeviceGetGraphMemAttribute(device, cyattr, cyvalue_ptr)
-    return (cudaError_t(err), cyvalue.pyObj())
+    return (_dict_cudaError_t[err], cyvalue.pyObj())
 {{endif}}
 
 {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}
@@ -31616,7 +31832,7 @@ def cudaDeviceSetGraphMemAttribute(int device, attr not None : cudaGraphMemAttri
     cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, value, is_getter=False)
     cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     err = cyruntime.cudaDeviceSetGraphMemAttribute(device, cyattr, cyvalue_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphClone' in found_functions}}
@@ -31659,7 +31875,7 @@ def cudaGraphClone(originalGraph):
     cyoriginalGraph = <cyruntime.cudaGraph_t><void_ptr>poriginalGraph
     cdef cudaGraph_t pGraphClone = cudaGraph_t()
     err = cyruntime.cudaGraphClone(<cyruntime.cudaGraph_t*>pGraphClone._pvt_ptr, cyoriginalGraph)
-    return (cudaError_t(err), pGraphClone)
+    return (_dict_cudaError_t[err], pGraphClone)
 {{endif}}
 
 {{if 'cudaGraphNodeFindInClone' in found_functions}}
@@ -31713,7 +31929,7 @@ def cudaGraphNodeFindInClone(originalNode, clonedGraph):
     cyoriginalNode = <cyruntime.cudaGraphNode_t><void_ptr>poriginalNode
     cdef cudaGraphNode_t pNode = cudaGraphNode_t()
     err = cyruntime.cudaGraphNodeFindInClone(<cyruntime.cudaGraphNode_t*>pNode._pvt_ptr, cyoriginalNode, cyclonedGraph)
-    return (cudaError_t(err), pNode)
+    return (_dict_cudaError_t[err], pNode)
 {{endif}}
 
 {{if 'cudaGraphNodeGetType' in found_functions}}
@@ -31750,7 +31966,7 @@ def cudaGraphNodeGetType(node):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cyruntime.cudaGraphNodeType pType
     err = cyruntime.cudaGraphNodeGetType(cynode, &pType)
-    return (cudaError_t(err), cudaGraphNodeType(pType))
+    return (_dict_cudaError_t[err], cudaGraphNodeType(pType))
 {{endif}}
 
 {{if 'cudaGraphGetNodes' in found_functions}}
@@ -31806,7 +32022,7 @@ def cudaGraphGetNodes(graph, size_t numNodes = 0):
         pynodes = [cudaGraphNode_t(init_value=<void_ptr>cynodes[idx]) for idx in range(_graph_length)]
     if cynodes is not NULL:
         free(cynodes)
-    return (cudaError_t(err), pynodes, numNodes)
+    return (_dict_cudaError_t[err], pynodes, numNodes)
 {{endif}}
 
 {{if 'cudaGraphGetRootNodes' in found_functions}}
@@ -31862,7 +32078,7 @@ def cudaGraphGetRootNodes(graph, size_t pNumRootNodes = 0):
         pypRootNodes = [cudaGraphNode_t(init_value=<void_ptr>cypRootNodes[idx]) for idx in range(_graph_length)]
     if cypRootNodes is not NULL:
         free(cypRootNodes)
-    return (cudaError_t(err), pypRootNodes, pNumRootNodes)
+    return (_dict_cudaError_t[err], pypRootNodes, pNumRootNodes)
 {{endif}}
 
 {{if 'cudaGraphGetEdges' in found_functions}}
@@ -31932,7 +32148,7 @@ def cudaGraphGetEdges(graph, size_t numEdges = 0):
         pyto = [cudaGraphNode_t(init_value=<void_ptr>cyto[idx]) for idx in range(_graph_length)]
     if cyto is not NULL:
         free(cyto)
-    return (cudaError_t(err), pyfrom_, pyto, numEdges)
+    return (_dict_cudaError_t[err], pyfrom_, pyto, numEdges)
 {{endif}}
 
 {{if 'cudaGraphGetEdges_v2' in found_functions}}
@@ -32019,7 +32235,7 @@ def cudaGraphGetEdges_v2(graph, size_t numEdges = 0):
         pyedgeData = [cudaGraphEdgeData(_ptr=<void_ptr>&cyedgeData[idx]) for idx in range(_graph_length)]
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (cudaError_t(err), pyfrom_, pyto, pyedgeData, numEdges)
+    return (_dict_cudaError_t[err], pyfrom_, pyto, pyedgeData, numEdges)
 {{endif}}
 
 {{if 'cudaGraphNodeGetDependencies' in found_functions}}
@@ -32076,7 +32292,7 @@ def cudaGraphNodeGetDependencies(node, size_t pNumDependencies = 0):
         pypDependencies = [cudaGraphNode_t(init_value=<void_ptr>cypDependencies[idx]) for idx in range(_graph_length)]
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pypDependencies, pNumDependencies)
+    return (_dict_cudaError_t[err], pypDependencies, pNumDependencies)
 {{endif}}
 
 {{if 'cudaGraphNodeGetDependencies_v2' in found_functions}}
@@ -32150,7 +32366,7 @@ def cudaGraphNodeGetDependencies_v2(node, size_t pNumDependencies = 0):
         pyedgeData = [cudaGraphEdgeData(_ptr=<void_ptr>&cyedgeData[idx]) for idx in range(_graph_length)]
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (cudaError_t(err), pypDependencies, pyedgeData, pNumDependencies)
+    return (_dict_cudaError_t[err], pypDependencies, pyedgeData, pNumDependencies)
 {{endif}}
 
 {{if 'cudaGraphNodeGetDependentNodes' in found_functions}}
@@ -32207,7 +32423,7 @@ def cudaGraphNodeGetDependentNodes(node, size_t pNumDependentNodes = 0):
         pypDependentNodes = [cudaGraphNode_t(init_value=<void_ptr>cypDependentNodes[idx]) for idx in range(_graph_length)]
     if cypDependentNodes is not NULL:
         free(cypDependentNodes)
-    return (cudaError_t(err), pypDependentNodes, pNumDependentNodes)
+    return (_dict_cudaError_t[err], pypDependentNodes, pNumDependentNodes)
 {{endif}}
 
 {{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}}
@@ -32281,7 +32497,7 @@ def cudaGraphNodeGetDependentNodes_v2(node, size_t pNumDependentNodes = 0):
         pyedgeData = [cudaGraphEdgeData(_ptr=<void_ptr>&cyedgeData[idx]) for idx in range(_graph_length)]
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (cudaError_t(err), pypDependentNodes, pyedgeData, pNumDependentNodes)
+    return (_dict_cudaError_t[err], pypDependentNodes, pyedgeData, pNumDependentNodes)
 {{endif}}
 
 {{if 'cudaGraphAddDependencies' in found_functions}}
@@ -32354,7 +32570,7 @@ def cudaGraphAddDependencies(graph, from_ : Optional[Tuple[cudaGraphNode_t] | Li
         free(cyfrom_)
     if cyto is not NULL:
         free(cyto)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddDependencies_v2' in found_functions}}
@@ -32440,7 +32656,7 @@ def cudaGraphAddDependencies_v2(graph, from_ : Optional[Tuple[cudaGraphNode_t] |
         free(cyto)
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphRemoveDependencies' in found_functions}}
@@ -32514,7 +32730,7 @@ def cudaGraphRemoveDependencies(graph, from_ : Optional[Tuple[cudaGraphNode_t] |
         free(cyfrom_)
     if cyto is not NULL:
         free(cyto)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphRemoveDependencies_v2' in found_functions}}
@@ -32603,7 +32819,7 @@ def cudaGraphRemoveDependencies_v2(graph, from_ : Optional[Tuple[cudaGraphNode_t
         free(cyto)
     if cyedgeData is not NULL:
         free(cyedgeData)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphDestroyNode' in found_functions}}
@@ -32641,7 +32857,7 @@ def cudaGraphDestroyNode(node):
         pnode = int(cudaGraphNode_t(node))
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     err = cyruntime.cudaGraphDestroyNode(cynode)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphInstantiate' in found_functions}}
@@ -32742,7 +32958,7 @@ def cudaGraphInstantiate(graph, unsigned long long flags):
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
     err = cyruntime.cudaGraphInstantiate(<cyruntime.cudaGraphExec_t*>pGraphExec._pvt_ptr, cygraph, flags)
-    return (cudaError_t(err), pGraphExec)
+    return (_dict_cudaError_t[err], pGraphExec)
 {{endif}}
 
 {{if 'cudaGraphInstantiateWithFlags' in found_functions}}
@@ -32845,7 +33061,7 @@ def cudaGraphInstantiateWithFlags(graph, unsigned long long flags):
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
     err = cyruntime.cudaGraphInstantiateWithFlags(<cyruntime.cudaGraphExec_t*>pGraphExec._pvt_ptr, cygraph, flags)
-    return (cudaError_t(err), pGraphExec)
+    return (_dict_cudaError_t[err], pGraphExec)
 {{endif}}
 
 {{if 'cudaGraphInstantiateWithParams' in found_functions}}
@@ -32989,7 +33205,7 @@ def cudaGraphInstantiateWithParams(graph, instantiateParams : Optional[cudaGraph
     cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
     cdef cyruntime.cudaGraphInstantiateParams* cyinstantiateParams_ptr = instantiateParams._pvt_ptr if instantiateParams != None else NULL
     err = cyruntime.cudaGraphInstantiateWithParams(<cyruntime.cudaGraphExec_t*>pGraphExec._pvt_ptr, cygraph, cyinstantiateParams_ptr)
-    return (cudaError_t(err), pGraphExec)
+    return (_dict_cudaError_t[err], pGraphExec)
 {{endif}}
 
 {{if 'cudaGraphExecGetFlags' in found_functions}}
@@ -33029,7 +33245,7 @@ def cudaGraphExecGetFlags(graphExec):
     cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     cdef unsigned long long flags = 0
     err = cyruntime.cudaGraphExecGetFlags(cygraphExec, &flags)
-    return (cudaError_t(err), flags)
+    return (_dict_cudaError_t[err], flags)
 {{endif}}
 
 {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}
@@ -33110,7 +33326,7 @@ def cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cyruntime.cudaKernelNodeParams* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphExecKernelNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}
@@ -33174,7 +33390,7 @@ def cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cyruntime.cudaMemcpy3DParms* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphExecMemcpyNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}
@@ -33246,7 +33462,7 @@ def cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, size_t count,
     cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
     cdef cyruntime.cudaMemcpyKind cykind = kind.value
     err = cyruntime.cudaGraphExecMemcpyNodeSetParams1D(cyhGraphExec, cynode, cydst_ptr, cysrc_ptr, count, cykind)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}
@@ -33315,7 +33531,7 @@ def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cyruntime.cudaMemsetParams* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphExecMemsetNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecHostNodeSetParams' in found_functions}}
@@ -33369,7 +33585,7 @@ def cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams : Optional[cuda
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cyruntime.cudaHostNodeParams* cypNodeParams_ptr = pNodeParams._pvt_ptr if pNodeParams != None else NULL
     err = cyruntime.cudaGraphExecHostNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}
@@ -33438,7 +33654,7 @@ def cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph):
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     err = cyruntime.cudaGraphExecChildGraphNodeSetParams(cyhGraphExec, cynode, cychildGraph)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}
@@ -33500,7 +33716,7 @@ def cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event):
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     err = cyruntime.cudaGraphExecEventRecordNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}
@@ -33562,7 +33778,7 @@ def cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event):
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     err = cyruntime.cudaGraphExecEventWaitNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
@@ -33621,7 +33837,7 @@ def cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodePa
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cyruntime.cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
@@ -33680,7 +33896,7 @@ def cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodePara
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cyruntime.cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphNodeSetEnabled' in found_functions}}
@@ -33742,7 +33958,7 @@ def cudaGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled):
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     err = cyruntime.cudaGraphNodeSetEnabled(cyhGraphExec, cyhNode, isEnabled)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphNodeGetEnabled' in found_functions}}
@@ -33798,7 +34014,7 @@ def cudaGraphNodeGetEnabled(hGraphExec, hNode):
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef unsigned int isEnabled = 0
     err = cyruntime.cudaGraphNodeGetEnabled(cyhGraphExec, cyhNode, &isEnabled)
-    return (cudaError_t(err), isEnabled)
+    return (_dict_cudaError_t[err], isEnabled)
 {{endif}}
 
 {{if 'cudaGraphExecUpdate' in found_functions}}
@@ -33971,7 +34187,7 @@ def cudaGraphExecUpdate(hGraphExec, hGraph):
     cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     cdef cudaGraphExecUpdateResultInfo resultInfo = cudaGraphExecUpdateResultInfo()
     err = cyruntime.cudaGraphExecUpdate(cyhGraphExec, cyhGraph, <cyruntime.cudaGraphExecUpdateResultInfo*>resultInfo._pvt_ptr)
-    return (cudaError_t(err), resultInfo)
+    return (_dict_cudaError_t[err], resultInfo)
 {{endif}}
 
 {{if 'cudaGraphUpload' in found_functions}}
@@ -34019,7 +34235,7 @@ def cudaGraphUpload(graphExec, stream):
         pgraphExec = int(cudaGraphExec_t(graphExec))
     cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     err = cyruntime.cudaGraphUpload(cygraphExec, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphLaunch' in found_functions}}
@@ -34072,7 +34288,7 @@ def cudaGraphLaunch(graphExec, stream):
         pgraphExec = int(cudaGraphExec_t(graphExec))
     cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     err = cyruntime.cudaGraphLaunch(cygraphExec, cystream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecDestroy' in found_functions}}
@@ -34106,7 +34322,7 @@ def cudaGraphExecDestroy(graphExec):
         pgraphExec = int(cudaGraphExec_t(graphExec))
     cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     err = cyruntime.cudaGraphExecDestroy(cygraphExec)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphDestroy' in found_functions}}
@@ -34140,7 +34356,7 @@ def cudaGraphDestroy(graph):
         pgraph = int(cudaGraph_t(graph))
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     err = cyruntime.cudaGraphDestroy(cygraph)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphDebugDotPrint' in found_functions}}
@@ -34179,7 +34395,7 @@ def cudaGraphDebugDotPrint(graph, char* path, unsigned int flags):
         pgraph = int(cudaGraph_t(graph))
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     err = cyruntime.cudaGraphDebugDotPrint(cygraph, path, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaUserObjectCreate' in found_functions}}
@@ -34238,7 +34454,7 @@ def cudaUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned in
     cyptr = utils.HelperInputVoidPtr(ptr)
     cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     err = cyruntime.cudaUserObjectCreate(<cyruntime.cudaUserObject_t*>object_out._pvt_ptr, cyptr_ptr, cydestroy, initialRefcount, flags)
-    return (cudaError_t(err), object_out)
+    return (_dict_cudaError_t[err], object_out)
 {{endif}}
 
 {{if 'cudaUserObjectRetain' in found_functions}}
@@ -34279,7 +34495,7 @@ def cudaUserObjectRetain(object, unsigned int count):
         pobject = int(cudaUserObject_t(object))
     cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
     err = cyruntime.cudaUserObjectRetain(cyobject, count)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaUserObjectRelease' in found_functions}}
@@ -34323,7 +34539,7 @@ def cudaUserObjectRelease(object, unsigned int count):
         pobject = int(cudaUserObject_t(object))
     cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
     err = cyruntime.cudaUserObjectRelease(cyobject, count)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphRetainUserObject' in found_functions}}
@@ -34378,7 +34594,7 @@ def cudaGraphRetainUserObject(graph, object, unsigned int count, unsigned int fl
         pgraph = int(cudaGraph_t(graph))
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     err = cyruntime.cudaGraphRetainUserObject(cygraph, cyobject, count, flags)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphReleaseUserObject' in found_functions}}
@@ -34428,7 +34644,7 @@ def cudaGraphReleaseUserObject(graph, object, unsigned int count):
         pgraph = int(cudaGraph_t(graph))
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     err = cyruntime.cudaGraphReleaseUserObject(cygraph, cyobject, count)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphAddNode' in found_functions}}
@@ -34503,7 +34719,7 @@ def cudaGraphAddNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | Li
     err = cyruntime.cudaGraphAddNode(<cyruntime.cudaGraphNode_t*>pGraphNode._pvt_ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._pvt_ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
     if cypDependencies is not NULL:
         free(cypDependencies)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphAddNode_v2' in found_functions}}
@@ -34594,7 +34810,7 @@ def cudaGraphAddNode_v2(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] |
         free(cypDependencies)
     if cydependencyData is not NULL:
         free(cydependencyData)
-    return (cudaError_t(err), pGraphNode)
+    return (_dict_cudaError_t[err], pGraphNode)
 {{endif}}
 
 {{if 'cudaGraphNodeSetParams' in found_functions}}
@@ -34637,7 +34853,7 @@ def cudaGraphNodeSetParams(node, nodeParams : Optional[cudaGraphNodeParams]):
     cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     cdef cyruntime.cudaGraphNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cyruntime.cudaGraphNodeSetParams(cynode, cynodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphExecNodeSetParams' in found_functions}}
@@ -34696,7 +34912,7 @@ def cudaGraphExecNodeSetParams(graphExec, node, nodeParams : Optional[cudaGraphN
     cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     cdef cyruntime.cudaGraphNodeParams* cynodeParams_ptr = nodeParams._pvt_ptr if nodeParams != None else NULL
     err = cyruntime.cudaGraphExecNodeSetParams(cygraphExec, cynode, cynodeParams_ptr)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGraphConditionalHandleCreate' in found_functions}}
@@ -34745,7 +34961,7 @@ def cudaGraphConditionalHandleCreate(graph, unsigned int defaultLaunchValue, uns
     cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphConditionalHandle pHandle_out = cudaGraphConditionalHandle()
     err = cyruntime.cudaGraphConditionalHandleCreate(<cyruntime.cudaGraphConditionalHandle*>pHandle_out._pvt_ptr, cygraph, defaultLaunchValue, flags)
-    return (cudaError_t(err), pHandle_out)
+    return (_dict_cudaError_t[err], pHandle_out)
 {{endif}}
 
 {{if 'cudaGetDriverEntryPoint' in found_functions}}
@@ -34840,7 +35056,7 @@ def cudaGetDriverEntryPoint(char* symbol, unsigned long long flags):
     cdef void_ptr funcPtr = 0
     cdef cyruntime.cudaDriverEntryPointQueryResult driverStatus
     err = cyruntime.cudaGetDriverEntryPoint(symbol, <void**>&funcPtr, flags, &driverStatus)
-    return (cudaError_t(err), funcPtr, cudaDriverEntryPointQueryResult(driverStatus))
+    return (_dict_cudaError_t[err], funcPtr, cudaDriverEntryPointQueryResult(driverStatus))
 {{endif}}
 
 {{if 'cudaGetDriverEntryPointByVersion' in found_functions}}
@@ -34943,7 +35159,7 @@ def cudaGetDriverEntryPointByVersion(char* symbol, unsigned int cudaVersion, uns
     cdef void_ptr funcPtr = 0
     cdef cyruntime.cudaDriverEntryPointQueryResult driverStatus
     err = cyruntime.cudaGetDriverEntryPointByVersion(symbol, <void**>&funcPtr, cudaVersion, flags, &driverStatus)
-    return (cudaError_t(err), funcPtr, cudaDriverEntryPointQueryResult(driverStatus))
+    return (_dict_cudaError_t[err], funcPtr, cudaDriverEntryPointQueryResult(driverStatus))
 {{endif}}
 
 {{if 'cudaLibraryLoadData' in found_functions}}
@@ -35037,7 +35253,7 @@ def cudaLibraryLoadData(code, jitOptions : Optional[Tuple[cudaJitOption] | List[
     if numLibraryOptions > len(libraryOptions): raise RuntimeError("List is too small: " + str(len(libraryOptions)) + " < " + str(numLibraryOptions))
     if numLibraryOptions > len(libraryOptionValues): raise RuntimeError("List is too small: " + str(len(libraryOptionValues)) + " < " + str(numLibraryOptions))
     err = cyruntime.cudaLibraryLoadData(<cyruntime.cudaLibrary_t*>library._pvt_ptr, cycode_ptr, cyjitOptions.data(), <void**><void_ptr>voidStarHelperjitOptionsValues.cptr, numJitOptions, cylibraryOptions.data(), <void**><void_ptr>voidStarHelperlibraryOptionValues.cptr, numLibraryOptions)
-    return (cudaError_t(err), library)
+    return (_dict_cudaError_t[err], library)
 {{endif}}
 
 {{if 'cudaLibraryLoadFromFile' in found_functions}}
@@ -35129,7 +35345,7 @@ def cudaLibraryLoadFromFile(char* fileName, jitOptions : Optional[Tuple[cudaJitO
     if numLibraryOptions > len(libraryOptions): raise RuntimeError("List is too small: " + str(len(libraryOptions)) + " < " + str(numLibraryOptions))
     if numLibraryOptions > len(libraryOptionValues): raise RuntimeError("List is too small: " + str(len(libraryOptionValues)) + " < " + str(numLibraryOptions))
     err = cyruntime.cudaLibraryLoadFromFile(<cyruntime.cudaLibrary_t*>library._pvt_ptr, fileName, cyjitOptions.data(), <void**><void_ptr>voidStarHelperjitOptionsValues.cptr, numJitOptions, cylibraryOptions.data(), <void**><void_ptr>voidStarHelperlibraryOptionValues.cptr, numLibraryOptions)
-    return (cudaError_t(err), library)
+    return (_dict_cudaError_t[err], library)
 {{endif}}
 
 {{if 'cudaLibraryUnload' in found_functions}}
@@ -35163,7 +35379,7 @@ def cudaLibraryUnload(library):
         plibrary = int(cudaLibrary_t(library))
     cylibrary = <cyruntime.cudaLibrary_t><void_ptr>plibrary
     err = cyruntime.cudaLibraryUnload(cylibrary)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaLibraryGetKernel' in found_functions}}
@@ -35204,7 +35420,7 @@ def cudaLibraryGetKernel(library, char* name):
     cylibrary = <cyruntime.cudaLibrary_t><void_ptr>plibrary
     cdef cudaKernel_t pKernel = cudaKernel_t()
     err = cyruntime.cudaLibraryGetKernel(<cyruntime.cudaKernel_t*>pKernel._pvt_ptr, cylibrary, name)
-    return (cudaError_t(err), pKernel)
+    return (_dict_cudaError_t[err], pKernel)
 {{endif}}
 
 {{if 'cudaLibraryGetGlobal' in found_functions}}
@@ -35253,7 +35469,7 @@ def cudaLibraryGetGlobal(library, char* name):
     cdef void_ptr dptr = 0
     cdef size_t numbytes = 0
     err = cyruntime.cudaLibraryGetGlobal(<void**>&dptr, &numbytes, cylibrary, name)
-    return (cudaError_t(err), dptr, numbytes)
+    return (_dict_cudaError_t[err], dptr, numbytes)
 {{endif}}
 
 {{if 'cudaLibraryGetManaged' in found_functions}}
@@ -35304,7 +35520,7 @@ def cudaLibraryGetManaged(library, char* name):
     cdef void_ptr dptr = 0
     cdef size_t numbytes = 0
     err = cyruntime.cudaLibraryGetManaged(<void**>&dptr, &numbytes, cylibrary, name)
-    return (cudaError_t(err), dptr, numbytes)
+    return (_dict_cudaError_t[err], dptr, numbytes)
 {{endif}}
 
 {{if 'cudaLibraryGetUnifiedFunction' in found_functions}}
@@ -35347,7 +35563,7 @@ def cudaLibraryGetUnifiedFunction(library, char* symbol):
     cylibrary = <cyruntime.cudaLibrary_t><void_ptr>plibrary
     cdef void_ptr fptr = 0
     err = cyruntime.cudaLibraryGetUnifiedFunction(<void**>&fptr, cylibrary, symbol)
-    return (cudaError_t(err), fptr)
+    return (_dict_cudaError_t[err], fptr)
 {{endif}}
 
 {{if 'cudaLibraryGetKernelCount' in found_functions}}
@@ -35384,7 +35600,7 @@ def cudaLibraryGetKernelCount(lib):
     cylib = <cyruntime.cudaLibrary_t><void_ptr>plib
     cdef unsigned int count = 0
     err = cyruntime.cudaLibraryGetKernelCount(&count, cylib)
-    return (cudaError_t(err), count)
+    return (_dict_cudaError_t[err], count)
 {{endif}}
 
 {{if 'cudaLibraryEnumerateKernels' in found_functions}}
@@ -35434,7 +35650,7 @@ def cudaLibraryEnumerateKernels(unsigned int numKernels, lib):
         pykernels = [cudaKernel_t(init_value=<void_ptr>cykernels[idx]) for idx in range(numKernels)]
     if cykernels is not NULL:
         free(cykernels)
-    return (cudaError_t(err), pykernels)
+    return (_dict_cudaError_t[err], pykernels)
 {{endif}}
 
 {{if 'cudaKernelSetAttributeForDevice' in found_functions}}
@@ -35539,7 +35755,7 @@ def cudaKernelSetAttributeForDevice(kernel, attr not None : cudaFuncAttribute, i
     cykernel = <cyruntime.cudaKernel_t><void_ptr>pkernel
     cdef cyruntime.cudaFuncAttribute cyattr = attr.value
     err = cyruntime.cudaKernelSetAttributeForDevice(cykernel, cyattr, value, device)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaGetExportTable' in found_functions}}
@@ -35550,7 +35766,7 @@ def cudaGetExportTable(pExportTableId : Optional[cudaUUID_t]):
     cdef void_ptr ppExportTable = 0
     cdef cyruntime.cudaUUID_t* cypExportTableId_ptr = pExportTableId._pvt_ptr if pExportTableId != None else NULL
     err = cyruntime.cudaGetExportTable(<const void**>&ppExportTable, cypExportTableId_ptr)
-    return (cudaError_t(err), ppExportTable)
+    return (_dict_cudaError_t[err], ppExportTable)
 {{endif}}
 
 {{if 'cudaGetKernel' in found_functions}}
@@ -35591,7 +35807,7 @@ def cudaGetKernel(entryFuncAddr):
     cyentryFuncAddr = utils.HelperInputVoidPtr(entryFuncAddr)
     cdef void* cyentryFuncAddr_ptr = <void*><void_ptr>cyentryFuncAddr.cptr
     err = cyruntime.cudaGetKernel(<cyruntime.cudaKernel_t*>kernelPtr._pvt_ptr, cyentryFuncAddr_ptr)
-    return (cudaError_t(err), kernelPtr)
+    return (_dict_cudaError_t[err], kernelPtr)
 {{endif}}
 
 {{if 'make_cudaPitchedPtr' in found_functions}}
@@ -35774,7 +35990,7 @@ def cudaGraphicsEGLRegisterImage(image, unsigned int flags):
     cyimage = <cyruntime.EGLImageKHR><void_ptr>pimage
     cdef cudaGraphicsResource_t pCudaResource = cudaGraphicsResource_t()
     err = cyruntime.cudaGraphicsEGLRegisterImage(pCudaResource._pvt_ptr, cyimage, flags)
-    return (cudaError_t(err), pCudaResource)
+    return (_dict_cudaError_t[err], pCudaResource)
 {{endif}}
 
 {{if True}}
@@ -35814,7 +36030,7 @@ def cudaEGLStreamConsumerConnect(eglStream):
     cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
     cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
     err = cyruntime.cudaEGLStreamConsumerConnect(<cyruntime.cudaEglStreamConnection*>conn._pvt_ptr, cyeglStream)
-    return (cudaError_t(err), conn)
+    return (_dict_cudaError_t[err], conn)
 {{endif}}
 
 {{if True}}
@@ -35858,7 +36074,7 @@ def cudaEGLStreamConsumerConnectWithFlags(eglStream, unsigned int flags):
     cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
     cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
     err = cyruntime.cudaEGLStreamConsumerConnectWithFlags(<cyruntime.cudaEglStreamConnection*>conn._pvt_ptr, cyeglStream, flags)
-    return (cudaError_t(err), conn)
+    return (_dict_cudaError_t[err], conn)
 {{endif}}
 
 {{if True}}
@@ -35894,7 +36110,7 @@ def cudaEGLStreamConsumerDisconnect(conn):
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
     err = cyruntime.cudaEGLStreamConsumerDisconnect(cyconn)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -35959,7 +36175,7 @@ def cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
     err = cyruntime.cudaEGLStreamConsumerAcquireFrame(cyconn, cypCudaResource, cypStream, timeout)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36018,7 +36234,7 @@ def cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream):
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
     err = cyruntime.cudaEGLStreamConsumerReleaseFrame(cyconn, cypCudaResource, cypStream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36078,7 +36294,7 @@ def cudaEGLStreamProducerConnect(eglStream, width, height):
     cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
     cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
     err = cyruntime.cudaEGLStreamProducerConnect(<cyruntime.cudaEglStreamConnection*>conn._pvt_ptr, cyeglStream, cywidth, cyheight)
-    return (cudaError_t(err), conn)
+    return (_dict_cudaError_t[err], conn)
 {{endif}}
 
 {{if True}}
@@ -36114,7 +36330,7 @@ def cudaEGLStreamProducerDisconnect(conn):
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
     err = cyruntime.cudaEGLStreamProducerDisconnect(cyconn)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36173,7 +36389,7 @@ def cudaEGLStreamProducerPresentFrame(conn, eglframe not None : cudaEglFrame, pS
     else:
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
     err = cyruntime.cudaEGLStreamProducerPresentFrame(cyconn, eglframe._pvt_ptr[0], cypStream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36227,7 +36443,7 @@ def cudaEGLStreamProducerReturnFrame(conn, eglframe : Optional[cudaEglFrame], pS
         raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
     cdef cyruntime.cudaEglFrame* cyeglframe_ptr = eglframe._pvt_ptr if eglframe != None else NULL
     err = cyruntime.cudaEGLStreamProducerReturnFrame(cyconn, cyeglframe_ptr, cypStream)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36278,7 +36494,7 @@ def cudaGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned
     cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     cdef cudaEglFrame eglFrame = cudaEglFrame()
     err = cyruntime.cudaGraphicsResourceGetMappedEglFrame(<cyruntime.cudaEglFrame*>eglFrame._pvt_ptr, cyresource, index, mipLevel)
-    return (cudaError_t(err), eglFrame)
+    return (_dict_cudaError_t[err], eglFrame)
 {{endif}}
 
 {{if True}}
@@ -36331,7 +36547,7 @@ def cudaEventCreateFromEGLSync(eglSync, unsigned int flags):
     cyeglSync = <cyruntime.EGLSyncKHR><void_ptr>peglSync
     cdef cudaEvent_t phEvent = cudaEvent_t()
     err = cyruntime.cudaEventCreateFromEGLSync(<cyruntime.cudaEvent_t*>phEvent._pvt_ptr, cyeglSync, flags)
-    return (cudaError_t(err), phEvent)
+    return (_dict_cudaError_t[err], phEvent)
 {{endif}}
 
 {{if 'cudaProfilerStart' in found_functions}}
@@ -36358,7 +36574,7 @@ def cudaProfilerStart():
     :py:obj:`~.cudaProfilerStop`, :py:obj:`~.cuProfilerStart`
     """
     err = cyruntime.cudaProfilerStart()
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if 'cudaProfilerStop' in found_functions}}
@@ -36385,7 +36601,7 @@ def cudaProfilerStop():
     :py:obj:`~.cudaProfilerStart`, :py:obj:`~.cuProfilerStop`
     """
     err = cyruntime.cudaProfilerStop()
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36450,7 +36666,7 @@ def cudaGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : cudaGLD
         pypCudaDevices = [<void_ptr>cypCudaDevices[idx] for idx in range(cudaDeviceCount)]
     if cypCudaDevices is not NULL:
         free(cypCudaDevices)
-    return (cudaError_t(err), pCudaDeviceCount, pypCudaDevices)
+    return (_dict_cudaError_t[err], pCudaDeviceCount, pypCudaDevices)
 {{endif}}
 
 {{if True}}
@@ -36547,7 +36763,7 @@ def cudaGraphicsGLRegisterImage(image, target, unsigned int flags):
     cyimage = <cyruntime.GLuint><void_ptr>pimage
     cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
     err = cyruntime.cudaGraphicsGLRegisterImage(resource._pvt_ptr, cyimage, cytarget, flags)
-    return (cudaError_t(err), resource)
+    return (_dict_cudaError_t[err], resource)
 {{endif}}
 
 {{if True}}
@@ -36601,7 +36817,7 @@ def cudaGraphicsGLRegisterBuffer(buffer, unsigned int flags):
     cybuffer = <cyruntime.GLuint><void_ptr>pbuffer
     cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
     err = cyruntime.cudaGraphicsGLRegisterBuffer(resource._pvt_ptr, cybuffer, flags)
-    return (cudaError_t(err), resource)
+    return (_dict_cudaError_t[err], resource)
 {{endif}}
 
 {{if True}}
@@ -36651,7 +36867,7 @@ def cudaVDPAUGetDevice(vdpDevice, vdpGetProcAddress):
     cyvdpDevice = <cyruntime.VdpDevice><void_ptr>pvdpDevice
     cdef int device = 0
     err = cyruntime.cudaVDPAUGetDevice(&device, cyvdpDevice, cyvdpGetProcAddress)
-    return (cudaError_t(err), device)
+    return (_dict_cudaError_t[err], device)
 {{endif}}
 
 {{if True}}
@@ -36709,7 +36925,7 @@ def cudaVDPAUSetVDPAUDevice(int device, vdpDevice, vdpGetProcAddress):
         pvdpDevice = int(VdpDevice(vdpDevice))
     cyvdpDevice = <cyruntime.VdpDevice><void_ptr>pvdpDevice
     err = cyruntime.cudaVDPAUSetVDPAUDevice(device, cyvdpDevice, cyvdpGetProcAddress)
-    return (cudaError_t(err),)
+    return (_dict_cudaError_t[err],)
 {{endif}}
 
 {{if True}}
@@ -36763,7 +36979,7 @@ def cudaGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags):
     cyvdpSurface = <cyruntime.VdpVideoSurface><void_ptr>pvdpSurface
     cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
     err = cyruntime.cudaGraphicsVDPAURegisterVideoSurface(resource._pvt_ptr, cyvdpSurface, flags)
-    return (cudaError_t(err), resource)
+    return (_dict_cudaError_t[err], resource)
 {{endif}}
 
 {{if True}}
@@ -36817,7 +37033,7 @@ def cudaGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags):
     cyvdpSurface = <cyruntime.VdpOutputSurface><void_ptr>pvdpSurface
     cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
     err = cyruntime.cudaGraphicsVDPAURegisterOutputSurface(resource._pvt_ptr, cyvdpSurface, flags)
-    return (cudaError_t(err), resource)
+    return (_dict_cudaError_t[err], resource)
 {{endif}}