# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
#
# Please refer to the NVIDIA end user license agreement (EULA) associated
# with this source code for terms and conditions that govern your use of
# this software. Any use, reproduction, disclosure, or distribution of
# this software and related documentation outside the terms of the EULA
# is strictly prohibited.

# cython: show_performance_hints=False

cimport cuda._cuda.ccuda as ccuda
from cuda._lib.ccudart.ccudart cimport *
from cuda._lib.ccudart.utils cimport *
from libc.stdlib cimport malloc, free, calloc
from libc cimport string
from libcpp cimport bool

cdef cudaPythonGlobal m_global = globalGetInstance()

{{if 'cudaDeviceReset' in found_functions}}

cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceReset()

{{endif}}

{{if 'cudaDeviceSynchronize' in found_functions}}

cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceSynchronize()

{{endif}}

{{if 'cudaDeviceSetLimit' in found_functions}}

cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceSetLimit(limit, value)

{{endif}}

{{if 'cudaDeviceGetLimit' in found_functions}}

cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetLimit(pValue, limit)

{{endif}}

{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}

cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmtDesc, device)

{{endif}}

{{if 'cudaDeviceGetCacheConfig' in found_functions}}

cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetCacheConfig(pCacheConfig)

{{endif}}

{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}

cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority)

{{endif}}

{{if 'cudaDeviceSetCacheConfig' in found_functions}}

cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceSetCacheConfig(cacheConfig)

{{endif}}

{{if 'cudaDeviceGetByPCIBusId' in found_functions}}

cdef cudaError_t cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetByPCIBusId(device, pciBusId)

{{endif}}

{{if 'cudaDeviceGetPCIBusId' in found_functions}}

cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetPCIBusId(pciBusId, length, device)

{{endif}}

{{if 'cudaIpcGetEventHandle' in found_functions}}

cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaIpcGetEventHandle(handle, event)

{{endif}}

{{if 'cudaIpcOpenEventHandle' in found_functions}}

cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaIpcOpenEventHandle(event, handle)

{{endif}}

{{if 'cudaIpcGetMemHandle' in found_functions}}

cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaIpcGetMemHandle(handle, devPtr)

{{endif}}

{{if 'cudaIpcOpenMemHandle' in found_functions}}

cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaIpcOpenMemHandle(devPtr, handle, flags)

{{endif}}

{{if 'cudaIpcCloseMemHandle' in found_functions}}

cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaIpcCloseMemHandle(devPtr)

{{endif}}

{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}

cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceFlushGPUDirectRDMAWrites(target, scope)

{{endif}}

{{if 'cudaDeviceRegisterAsyncNotification' in found_functions}}

cdef cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceRegisterAsyncNotification(device, callbackFunc, userData, callback)

{{endif}}

{{if 'cudaDeviceUnregisterAsyncNotification' in found_functions}}

cdef cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceUnregisterAsyncNotification(device, callback)

{{endif}}

{{if 'cudaDeviceGetSharedMemConfig' in found_functions}}

cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetSharedMemConfig(pConfig)

{{endif}}

{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}

cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceSetSharedMemConfig(config)

{{endif}}

{{if 'cudaGetLastError' in found_functions}}

cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetLastError()

{{endif}}

{{if 'cudaPeekAtLastError' in found_functions}}

cdef cudaError_t cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaPeekAtLastError()

{{endif}}

{{if 'cudaGetErrorName' in found_functions}}

cdef const char* cudaGetErrorName(cudaError_t error) except ?NULL nogil:
    cdef const char* pStr = "unrecognized error code"
    {{if 'cudaSuccess' in found_values}}
    if error == cudaSuccess:
        return "cudaSuccess"{{endif}}
    {{if 'cudaErrorInvalidValue' in found_values}}
    if error == cudaErrorInvalidValue:
        return "cudaErrorInvalidValue"{{endif}}
    {{if 'cudaErrorMemoryAllocation' in found_values}}
    if error == cudaErrorMemoryAllocation:
        return "cudaErrorMemoryAllocation"{{endif}}
    {{if 'cudaErrorInitializationError' in found_values}}
    if error == cudaErrorInitializationError:
        return "cudaErrorInitializationError"{{endif}}
    {{if 'cudaErrorCudartUnloading' in found_values}}
    if error == cudaErrorCudartUnloading:
        return "cudaErrorCudartUnloading"{{endif}}
    {{if 'cudaErrorProfilerDisabled' in found_values}}
    if error == cudaErrorProfilerDisabled:
        return "cudaErrorProfilerDisabled"{{endif}}
    {{if 'cudaErrorProfilerNotInitialized' in found_values}}
    if error == cudaErrorProfilerNotInitialized:
        return "cudaErrorProfilerNotInitialized"{{endif}}
    {{if 'cudaErrorProfilerAlreadyStarted' in found_values}}
    if error == cudaErrorProfilerAlreadyStarted:
        return "cudaErrorProfilerAlreadyStarted"{{endif}}
    {{if 'cudaErrorProfilerAlreadyStopped' in found_values}}
    if error == cudaErrorProfilerAlreadyStopped:
        return "cudaErrorProfilerAlreadyStopped"{{endif}}
    {{if 'cudaErrorInvalidConfiguration' in found_values}}
    if error == cudaErrorInvalidConfiguration:
        return "cudaErrorInvalidConfiguration"{{endif}}
    {{if 'cudaErrorInvalidPitchValue' in found_values}}
    if error == cudaErrorInvalidPitchValue:
        return "cudaErrorInvalidPitchValue"{{endif}}
    {{if 'cudaErrorInvalidSymbol' in found_values}}
    if error == cudaErrorInvalidSymbol:
        return "cudaErrorInvalidSymbol"{{endif}}
    {{if 'cudaErrorInvalidHostPointer' in found_values}}
    if error == cudaErrorInvalidHostPointer:
        return "cudaErrorInvalidHostPointer"{{endif}}
    {{if 'cudaErrorInvalidDevicePointer' in found_values}}
    if error == cudaErrorInvalidDevicePointer:
        return "cudaErrorInvalidDevicePointer"{{endif}}
    {{if 'cudaErrorInvalidTexture' in found_values}}
    if error == cudaErrorInvalidTexture:
        return "cudaErrorInvalidTexture"{{endif}}
    {{if 'cudaErrorInvalidTextureBinding' in found_values}}
    if error == cudaErrorInvalidTextureBinding:
        return "cudaErrorInvalidTextureBinding"{{endif}}
    {{if 'cudaErrorInvalidChannelDescriptor' in found_values}}
    if error == cudaErrorInvalidChannelDescriptor:
        return "cudaErrorInvalidChannelDescriptor"{{endif}}
    {{if 'cudaErrorInvalidMemcpyDirection' in found_values}}
    if error == cudaErrorInvalidMemcpyDirection:
        return "cudaErrorInvalidMemcpyDirection"{{endif}}
    {{if 'cudaErrorAddressOfConstant' in found_values}}
    if error == cudaErrorAddressOfConstant:
        return "cudaErrorAddressOfConstant"{{endif}}
    {{if 'cudaErrorTextureFetchFailed' in found_values}}
    if error == cudaErrorTextureFetchFailed:
        return "cudaErrorTextureFetchFailed"{{endif}}
    {{if 'cudaErrorTextureNotBound' in found_values}}
    if error == cudaErrorTextureNotBound:
        return "cudaErrorTextureNotBound"{{endif}}
    {{if 'cudaErrorSynchronizationError' in found_values}}
    if error == cudaErrorSynchronizationError:
        return "cudaErrorSynchronizationError"{{endif}}
    {{if 'cudaErrorInvalidFilterSetting' in found_values}}
    if error == cudaErrorInvalidFilterSetting:
        return "cudaErrorInvalidFilterSetting"{{endif}}
    {{if 'cudaErrorInvalidNormSetting' in found_values}}
    if error == cudaErrorInvalidNormSetting:
        return "cudaErrorInvalidNormSetting"{{endif}}
    {{if 'cudaErrorMixedDeviceExecution' in found_values}}
    if error == cudaErrorMixedDeviceExecution:
        return "cudaErrorMixedDeviceExecution"{{endif}}
    {{if 'cudaErrorNotYetImplemented' in found_values}}
    if error == cudaErrorNotYetImplemented:
        return "cudaErrorNotYetImplemented"{{endif}}
    {{if 'cudaErrorMemoryValueTooLarge' in found_values}}
    if error == cudaErrorMemoryValueTooLarge:
        return "cudaErrorMemoryValueTooLarge"{{endif}}
    {{if 'cudaErrorStubLibrary' in found_values}}
    if error == cudaErrorStubLibrary:
        return "cudaErrorStubLibrary"{{endif}}
    {{if 'cudaErrorInsufficientDriver' in found_values}}
    if error == cudaErrorInsufficientDriver:
        return "cudaErrorInsufficientDriver"{{endif}}
    {{if 'cudaErrorCallRequiresNewerDriver' in found_values}}
    if error == cudaErrorCallRequiresNewerDriver:
        return "cudaErrorCallRequiresNewerDriver"{{endif}}
    {{if 'cudaErrorInvalidSurface' in found_values}}
    if error == cudaErrorInvalidSurface:
        return "cudaErrorInvalidSurface"{{endif}}
    {{if 'cudaErrorDuplicateVariableName' in found_values}}
    if error == cudaErrorDuplicateVariableName:
        return "cudaErrorDuplicateVariableName"{{endif}}
    {{if 'cudaErrorDuplicateTextureName' in found_values}}
    if error == cudaErrorDuplicateTextureName:
        return "cudaErrorDuplicateTextureName"{{endif}}
    {{if 'cudaErrorDuplicateSurfaceName' in found_values}}
    if error == cudaErrorDuplicateSurfaceName:
        return "cudaErrorDuplicateSurfaceName"{{endif}}
    {{if 'cudaErrorDevicesUnavailable' in found_values}}
    if error == cudaErrorDevicesUnavailable:
        return "cudaErrorDevicesUnavailable"{{endif}}
    {{if 'cudaErrorIncompatibleDriverContext' in found_values}}
    if error == cudaErrorIncompatibleDriverContext:
        return "cudaErrorIncompatibleDriverContext"{{endif}}
    {{if 'cudaErrorMissingConfiguration' in found_values}}
    if error == cudaErrorMissingConfiguration:
        return "cudaErrorMissingConfiguration"{{endif}}
    {{if 'cudaErrorPriorLaunchFailure' in found_values}}
    if error == cudaErrorPriorLaunchFailure:
        return "cudaErrorPriorLaunchFailure"{{endif}}
    {{if 'cudaErrorLaunchMaxDepthExceeded' in found_values}}
    if error == cudaErrorLaunchMaxDepthExceeded:
        return "cudaErrorLaunchMaxDepthExceeded"{{endif}}
    {{if 'cudaErrorLaunchFileScopedTex' in found_values}}
    if error == cudaErrorLaunchFileScopedTex:
        return "cudaErrorLaunchFileScopedTex"{{endif}}
    {{if 'cudaErrorLaunchFileScopedSurf' in found_values}}
    if error == cudaErrorLaunchFileScopedSurf:
        return "cudaErrorLaunchFileScopedSurf"{{endif}}
    {{if 'cudaErrorSyncDepthExceeded' in found_values}}
    if error == cudaErrorSyncDepthExceeded:
        return "cudaErrorSyncDepthExceeded"{{endif}}
    {{if 'cudaErrorLaunchPendingCountExceeded' in found_values}}
    if error == cudaErrorLaunchPendingCountExceeded:
        return "cudaErrorLaunchPendingCountExceeded"{{endif}}
    {{if 'cudaErrorInvalidDeviceFunction' in found_values}}
    if error == cudaErrorInvalidDeviceFunction:
        return "cudaErrorInvalidDeviceFunction"{{endif}}
    {{if 'cudaErrorNoDevice' in found_values}}
    if error == cudaErrorNoDevice:
        return "cudaErrorNoDevice"{{endif}}
    {{if 'cudaErrorInvalidDevice' in found_values}}
    if error == cudaErrorInvalidDevice:
        return "cudaErrorInvalidDevice"{{endif}}
    {{if 'cudaErrorDeviceNotLicensed' in found_values}}
    if error == cudaErrorDeviceNotLicensed:
        return "cudaErrorDeviceNotLicensed"{{endif}}
    {{if 'cudaErrorSoftwareValidityNotEstablished' in found_values}}
    if error == cudaErrorSoftwareValidityNotEstablished:
        return "cudaErrorSoftwareValidityNotEstablished"{{endif}}
    {{if 'cudaErrorStartupFailure' in found_values}}
    if error == cudaErrorStartupFailure:
        return "cudaErrorStartupFailure"{{endif}}
    {{if 'cudaErrorInvalidKernelImage' in found_values}}
    if error == cudaErrorInvalidKernelImage:
        return "cudaErrorInvalidKernelImage"{{endif}}
    {{if 'cudaErrorDeviceUninitialized' in found_values}}
    if error == cudaErrorDeviceUninitialized:
        return "cudaErrorDeviceUninitialized"{{endif}}
    {{if 'cudaErrorMapBufferObjectFailed' in found_values}}
    if error == cudaErrorMapBufferObjectFailed:
        return "cudaErrorMapBufferObjectFailed"{{endif}}
    {{if 'cudaErrorUnmapBufferObjectFailed' in found_values}}
    if error == cudaErrorUnmapBufferObjectFailed:
        return "cudaErrorUnmapBufferObjectFailed"{{endif}}
    {{if 'cudaErrorArrayIsMapped' in found_values}}
    if error == cudaErrorArrayIsMapped:
        return "cudaErrorArrayIsMapped"{{endif}}
    {{if 'cudaErrorAlreadyMapped' in found_values}}
    if error == cudaErrorAlreadyMapped:
        return "cudaErrorAlreadyMapped"{{endif}}
    {{if 'cudaErrorNoKernelImageForDevice' in found_values}}
    if error == cudaErrorNoKernelImageForDevice:
        return "cudaErrorNoKernelImageForDevice"{{endif}}
    {{if 'cudaErrorAlreadyAcquired' in found_values}}
    if error == cudaErrorAlreadyAcquired:
        return "cudaErrorAlreadyAcquired"{{endif}}
    {{if 'cudaErrorNotMapped' in found_values}}
    if error == cudaErrorNotMapped:
        return "cudaErrorNotMapped"{{endif}}
    {{if 'cudaErrorNotMappedAsArray' in found_values}}
    if error == cudaErrorNotMappedAsArray:
        return "cudaErrorNotMappedAsArray"{{endif}}
    {{if 'cudaErrorNotMappedAsPointer' in found_values}}
    if error == cudaErrorNotMappedAsPointer:
        return "cudaErrorNotMappedAsPointer"{{endif}}
    {{if 'cudaErrorECCUncorrectable' in found_values}}
    if error == cudaErrorECCUncorrectable:
        return "cudaErrorECCUncorrectable"{{endif}}
    {{if 'cudaErrorUnsupportedLimit' in found_values}}
    if error == cudaErrorUnsupportedLimit:
        return "cudaErrorUnsupportedLimit"{{endif}}
    {{if 'cudaErrorDeviceAlreadyInUse' in found_values}}
    if error == cudaErrorDeviceAlreadyInUse:
        return "cudaErrorDeviceAlreadyInUse"{{endif}}
    {{if 'cudaErrorPeerAccessUnsupported' in found_values}}
    if error == cudaErrorPeerAccessUnsupported:
        return "cudaErrorPeerAccessUnsupported"{{endif}}
    {{if 'cudaErrorInvalidPtx' in found_values}}
    if error == cudaErrorInvalidPtx:
        return "cudaErrorInvalidPtx"{{endif}}
    {{if 'cudaErrorInvalidGraphicsContext' in found_values}}
    if error == cudaErrorInvalidGraphicsContext:
        return "cudaErrorInvalidGraphicsContext"{{endif}}
    {{if 'cudaErrorNvlinkUncorrectable' in found_values}}
    if error == cudaErrorNvlinkUncorrectable:
        return "cudaErrorNvlinkUncorrectable"{{endif}}
    {{if 'cudaErrorJitCompilerNotFound' in found_values}}
    if error == cudaErrorJitCompilerNotFound:
        return "cudaErrorJitCompilerNotFound"{{endif}}
    {{if 'cudaErrorUnsupportedPtxVersion' in found_values}}
    if error == cudaErrorUnsupportedPtxVersion:
        return "cudaErrorUnsupportedPtxVersion"{{endif}}
    {{if 'cudaErrorJitCompilationDisabled' in found_values}}
    if error == cudaErrorJitCompilationDisabled:
        return "cudaErrorJitCompilationDisabled"{{endif}}
    {{if 'cudaErrorUnsupportedExecAffinity' in found_values}}
    if error == cudaErrorUnsupportedExecAffinity:
        return "cudaErrorUnsupportedExecAffinity"{{endif}}
    {{if 'cudaErrorUnsupportedDevSideSync' in found_values}}
    if error == cudaErrorUnsupportedDevSideSync:
        return "cudaErrorUnsupportedDevSideSync"{{endif}}
    {{if 'cudaErrorInvalidSource' in found_values}}
    if error == cudaErrorInvalidSource:
        return "cudaErrorInvalidSource"{{endif}}
    {{if 'cudaErrorFileNotFound' in found_values}}
    if error == cudaErrorFileNotFound:
        return "cudaErrorFileNotFound"{{endif}}
    {{if 'cudaErrorSharedObjectSymbolNotFound' in found_values}}
    if error == cudaErrorSharedObjectSymbolNotFound:
        return "cudaErrorSharedObjectSymbolNotFound"{{endif}}
    {{if 'cudaErrorSharedObjectInitFailed' in found_values}}
    if error == cudaErrorSharedObjectInitFailed:
        return "cudaErrorSharedObjectInitFailed"{{endif}}
    {{if 'cudaErrorOperatingSystem' in found_values}}
    if error == cudaErrorOperatingSystem:
        return "cudaErrorOperatingSystem"{{endif}}
    {{if 'cudaErrorInvalidResourceHandle' in found_values}}
    if error == cudaErrorInvalidResourceHandle:
        return "cudaErrorInvalidResourceHandle"{{endif}}
    {{if 'cudaErrorIllegalState' in found_values}}
    if error == cudaErrorIllegalState:
        return "cudaErrorIllegalState"{{endif}}
    {{if 'cudaErrorLossyQuery' in found_values}}
    if error == cudaErrorLossyQuery:
        return "cudaErrorLossyQuery"{{endif}}
    {{if 'cudaErrorSymbolNotFound' in found_values}}
    if error == cudaErrorSymbolNotFound:
        return "cudaErrorSymbolNotFound"{{endif}}
    {{if 'cudaErrorNotReady' in found_values}}
    if error == cudaErrorNotReady:
        return "cudaErrorNotReady"{{endif}}
    {{if 'cudaErrorIllegalAddress' in found_values}}
    if error == cudaErrorIllegalAddress:
        return "cudaErrorIllegalAddress"{{endif}}
    {{if 'cudaErrorLaunchOutOfResources' in found_values}}
    if error == cudaErrorLaunchOutOfResources:
        return "cudaErrorLaunchOutOfResources"{{endif}}
    {{if 'cudaErrorLaunchTimeout' in found_values}}
    if error == cudaErrorLaunchTimeout:
        return "cudaErrorLaunchTimeout"{{endif}}
    {{if 'cudaErrorLaunchIncompatibleTexturing' in found_values}}
    if error == cudaErrorLaunchIncompatibleTexturing:
        return "cudaErrorLaunchIncompatibleTexturing"{{endif}}
    {{if 'cudaErrorPeerAccessAlreadyEnabled' in found_values}}
    if error == cudaErrorPeerAccessAlreadyEnabled:
        return "cudaErrorPeerAccessAlreadyEnabled"{{endif}}
    {{if 'cudaErrorPeerAccessNotEnabled' in found_values}}
    if error == cudaErrorPeerAccessNotEnabled:
        return "cudaErrorPeerAccessNotEnabled"{{endif}}
    {{if 'cudaErrorSetOnActiveProcess' in found_values}}
    if error == cudaErrorSetOnActiveProcess:
        return "cudaErrorSetOnActiveProcess"{{endif}}
    {{if 'cudaErrorContextIsDestroyed' in found_values}}
    if error == cudaErrorContextIsDestroyed:
        return "cudaErrorContextIsDestroyed"{{endif}}
    {{if 'cudaErrorAssert' in found_values}}
    if error == cudaErrorAssert:
        return "cudaErrorAssert"{{endif}}
    {{if 'cudaErrorTooManyPeers' in found_values}}
    if error == cudaErrorTooManyPeers:
        return "cudaErrorTooManyPeers"{{endif}}
    {{if 'cudaErrorHostMemoryAlreadyRegistered' in found_values}}
    if error == cudaErrorHostMemoryAlreadyRegistered:
        return "cudaErrorHostMemoryAlreadyRegistered"{{endif}}
    {{if 'cudaErrorHostMemoryNotRegistered' in found_values}}
    if error == cudaErrorHostMemoryNotRegistered:
        return "cudaErrorHostMemoryNotRegistered"{{endif}}
    {{if 'cudaErrorHardwareStackError' in found_values}}
    if error == cudaErrorHardwareStackError:
        return "cudaErrorHardwareStackError"{{endif}}
    {{if 'cudaErrorIllegalInstruction' in found_values}}
    if error == cudaErrorIllegalInstruction:
        return "cudaErrorIllegalInstruction"{{endif}}
    {{if 'cudaErrorMisalignedAddress' in found_values}}
    if error == cudaErrorMisalignedAddress:
        return "cudaErrorMisalignedAddress"{{endif}}
    {{if 'cudaErrorInvalidAddressSpace' in found_values}}
    if error == cudaErrorInvalidAddressSpace:
        return "cudaErrorInvalidAddressSpace"{{endif}}
    {{if 'cudaErrorInvalidPc' in found_values}}
    if error == cudaErrorInvalidPc:
        return "cudaErrorInvalidPc"{{endif}}
    {{if 'cudaErrorLaunchFailure' in found_values}}
    if error == cudaErrorLaunchFailure:
        return "cudaErrorLaunchFailure"{{endif}}
    {{if 'cudaErrorCooperativeLaunchTooLarge' in found_values}}
    if error == cudaErrorCooperativeLaunchTooLarge:
        return "cudaErrorCooperativeLaunchTooLarge"{{endif}}
    {{if 'cudaErrorNotPermitted' in found_values}}
    if error == cudaErrorNotPermitted:
        return "cudaErrorNotPermitted"{{endif}}
    {{if 'cudaErrorNotSupported' in found_values}}
    if error == cudaErrorNotSupported:
        return "cudaErrorNotSupported"{{endif}}
    {{if 'cudaErrorSystemNotReady' in found_values}}
    if error == cudaErrorSystemNotReady:
        return "cudaErrorSystemNotReady"{{endif}}
    {{if 'cudaErrorSystemDriverMismatch' in found_values}}
    if error == cudaErrorSystemDriverMismatch:
        return "cudaErrorSystemDriverMismatch"{{endif}}
    {{if 'cudaErrorCompatNotSupportedOnDevice' in found_values}}
    if error == cudaErrorCompatNotSupportedOnDevice:
        return "cudaErrorCompatNotSupportedOnDevice"{{endif}}
    {{if 'cudaErrorMpsConnectionFailed' in found_values}}
    if error == cudaErrorMpsConnectionFailed:
        return "cudaErrorMpsConnectionFailed"{{endif}}
    {{if 'cudaErrorMpsRpcFailure' in found_values}}
    if error == cudaErrorMpsRpcFailure:
        return "cudaErrorMpsRpcFailure"{{endif}}
    {{if 'cudaErrorMpsServerNotReady' in found_values}}
    if error == cudaErrorMpsServerNotReady:
        return "cudaErrorMpsServerNotReady"{{endif}}
    {{if 'cudaErrorMpsMaxClientsReached' in found_values}}
    if error == cudaErrorMpsMaxClientsReached:
        return "cudaErrorMpsMaxClientsReached"{{endif}}
    {{if 'cudaErrorMpsMaxConnectionsReached' in found_values}}
    if error == cudaErrorMpsMaxConnectionsReached:
        return "cudaErrorMpsMaxConnectionsReached"{{endif}}
    {{if 'cudaErrorMpsClientTerminated' in found_values}}
    if error == cudaErrorMpsClientTerminated:
        return "cudaErrorMpsClientTerminated"{{endif}}
    {{if 'cudaErrorCdpNotSupported' in found_values}}
    if error == cudaErrorCdpNotSupported:
        return "cudaErrorCdpNotSupported"{{endif}}
    {{if 'cudaErrorCdpVersionMismatch' in found_values}}
    if error == cudaErrorCdpVersionMismatch:
        return "cudaErrorCdpVersionMismatch"{{endif}}
    {{if 'cudaErrorStreamCaptureUnsupported' in found_values}}
    if error == cudaErrorStreamCaptureUnsupported:
        return "cudaErrorStreamCaptureUnsupported"{{endif}}
    {{if 'cudaErrorStreamCaptureInvalidated' in found_values}}
    if error == cudaErrorStreamCaptureInvalidated:
        return "cudaErrorStreamCaptureInvalidated"{{endif}}
    {{if 'cudaErrorStreamCaptureMerge' in found_values}}
    if error == cudaErrorStreamCaptureMerge:
        return "cudaErrorStreamCaptureMerge"{{endif}}
    {{if 'cudaErrorStreamCaptureUnmatched' in found_values}}
    if error == cudaErrorStreamCaptureUnmatched:
        return "cudaErrorStreamCaptureUnmatched"{{endif}}
    {{if 'cudaErrorStreamCaptureUnjoined' in found_values}}
    if error == cudaErrorStreamCaptureUnjoined:
        return "cudaErrorStreamCaptureUnjoined"{{endif}}
    {{if 'cudaErrorStreamCaptureIsolation' in found_values}}
    if error == cudaErrorStreamCaptureIsolation:
        return "cudaErrorStreamCaptureIsolation"{{endif}}
    {{if 'cudaErrorStreamCaptureImplicit' in found_values}}
    if error == cudaErrorStreamCaptureImplicit:
        return "cudaErrorStreamCaptureImplicit"{{endif}}
    {{if 'cudaErrorCapturedEvent' in found_values}}
    if error == cudaErrorCapturedEvent:
        return "cudaErrorCapturedEvent"{{endif}}
    {{if 'cudaErrorStreamCaptureWrongThread' in found_values}}
    if error == cudaErrorStreamCaptureWrongThread:
        return "cudaErrorStreamCaptureWrongThread"{{endif}}
    {{if 'cudaErrorTimeout' in found_values}}
    if error == cudaErrorTimeout:
        return "cudaErrorTimeout"{{endif}}
    {{if 'cudaErrorGraphExecUpdateFailure' in found_values}}
    if error == cudaErrorGraphExecUpdateFailure:
        return "cudaErrorGraphExecUpdateFailure"{{endif}}
    {{if 'cudaErrorExternalDevice' in found_values}}
    if error == cudaErrorExternalDevice:
        return "cudaErrorExternalDevice"{{endif}}
    {{if 'cudaErrorInvalidClusterSize' in found_values}}
    if error == cudaErrorInvalidClusterSize:
        return "cudaErrorInvalidClusterSize"{{endif}}
    {{if 'cudaErrorFunctionNotLoaded' in found_values}}
    if error == cudaErrorFunctionNotLoaded:
        return "cudaErrorFunctionNotLoaded"{{endif}}
    {{if 'cudaErrorInvalidResourceType' in found_values}}
    if error == cudaErrorInvalidResourceType:
        return "cudaErrorInvalidResourceType"{{endif}}
    {{if 'cudaErrorInvalidResourceConfiguration' in found_values}}
    if error == cudaErrorInvalidResourceConfiguration:
        return "cudaErrorInvalidResourceConfiguration"{{endif}}
    {{if 'cudaErrorUnknown' in found_values}}
    if error == cudaErrorUnknown:
        return "cudaErrorUnknown"{{endif}}
    {{if 'cudaErrorApiFailureBase' in found_values}}
    if error == cudaErrorApiFailureBase:
        return "cudaErrorApiFailureBase"{{endif}}
    return pStr

{{endif}}

{{if 'cudaGetErrorString' in found_functions}}

cdef const char* cudaGetErrorString(cudaError_t error) except ?NULL nogil:
    return _cudaGetErrorString(error)

{{endif}}

{{if 'cudaGetDeviceCount' in found_functions}}

cdef cudaError_t cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetDeviceCount(count)

{{endif}}

{{if 'cudaGetDeviceProperties_v2' in found_functions}}

cdef cudaError_t cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetDeviceProperties_v2(prop, device)

{{endif}}

{{if 'cudaDeviceGetAttribute' in found_functions}}

cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetAttribute(value, attr, device)

{{endif}}

{{if 'cudaDeviceGetDefaultMemPool' in found_functions}}

cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetDefaultMemPool(memPool, device)

{{endif}}

{{if 'cudaDeviceSetMemPool' in found_functions}}

cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceSetMemPool(device, memPool)

{{endif}}

{{if 'cudaDeviceGetMemPool' in found_functions}}

cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetMemPool(memPool, device)

{{endif}}

{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}}

cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags)

{{endif}}

{{if 'cudaDeviceGetP2PAttribute' in found_functions}}

cdef cudaError_t cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetP2PAttribute(value, attr, srcDevice, dstDevice)

{{endif}}

{{if 'cudaChooseDevice' in found_functions}}

cdef cudaError_t cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaChooseDevice(device, prop)

{{endif}}

{{if 'cudaInitDevice' in found_functions}}

cdef cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaInitDevice(device, deviceFlags, flags)

{{endif}}

{{if 'cudaSetDevice' in found_functions}}

cdef cudaError_t cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaSetDevice(device)

{{endif}}

{{if 'cudaGetDevice' in found_functions}}

cdef cudaError_t cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetDevice(device)

{{endif}}

{{if 'cudaSetDeviceFlags' in found_functions}}

cdef cudaError_t cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaSetDeviceFlags(flags)

{{endif}}

{{if 'cudaGetDeviceFlags' in found_functions}}

cdef cudaError_t cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetDeviceFlags(flags)

{{endif}}

{{if 'cudaStreamCreate' in found_functions}}

cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamCreate(pStream)

{{endif}}

{{if 'cudaStreamCreateWithFlags' in found_functions}}

cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamCreateWithFlags(pStream, flags)

{{endif}}

{{if 'cudaStreamCreateWithPriority' in found_functions}}

cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamCreateWithPriority(pStream, flags, priority)

{{endif}}

{{if 'cudaStreamGetPriority' in found_functions}}

cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamGetPriority(hStream, priority)

{{endif}}

{{if 'cudaStreamGetFlags' in found_functions}}

cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamGetFlags(hStream, flags)

{{endif}}

{{if 'cudaStreamGetId' in found_functions}}

cdef cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long* streamId) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamGetId(hStream, streamId)

{{endif}}

{{if 'cudaCtxResetPersistingL2Cache' in found_functions}}

cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaCtxResetPersistingL2Cache()

{{endif}}

{{if 'cudaStreamCopyAttributes' in found_functions}}

cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamCopyAttributes(dst, src)

{{endif}}

{{if 'cudaStreamGetAttribute' in found_functions}}

cdef cudaError_t cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamGetAttribute(hStream, attr, value_out)

{{endif}}

{{if 'cudaStreamSetAttribute' in found_functions}}

cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamSetAttribute(hStream, attr, value)

{{endif}}

{{if 'cudaStreamDestroy' in found_functions}}

cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamDestroy(stream)

{{endif}}

{{if 'cudaStreamWaitEvent' in found_functions}}

cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamWaitEvent(stream, event, flags)

{{endif}}

{{if 'cudaStreamAddCallback' in found_functions}}

cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamAddCallback(stream, callback, userData, flags)

{{endif}}

{{if 'cudaStreamSynchronize' in found_functions}}

cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamSynchronize(stream)

{{endif}}

{{if 'cudaStreamQuery' in found_functions}}

cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamQuery(stream)

{{endif}}

{{if 'cudaStreamAttachMemAsync' in found_functions}}

cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamAttachMemAsync(stream, devPtr, length, flags)

{{endif}}

{{if 'cudaStreamBeginCapture' in found_functions}}

cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamBeginCapture(stream, mode)

{{endif}}

{{if 'cudaStreamBeginCaptureToGraph' in found_functions}}

cdef cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamBeginCaptureToGraph(stream, graph, dependencies, dependencyData, numDependencies, mode)

{{endif}}

{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}}

cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaThreadExchangeStreamCaptureMode(mode)

{{endif}}

{{if 'cudaStreamEndCapture' in found_functions}}

cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamEndCapture(stream, pGraph)

{{endif}}

{{if 'cudaStreamIsCapturing' in found_functions}}

cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamIsCapturing(stream, pCaptureStatus)

{{endif}}

{{if 'cudaStreamGetCaptureInfo_v2' in found_functions}}

cdef cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamGetCaptureInfo_v2(stream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)

{{endif}}

{{if 'cudaStreamGetCaptureInfo_v3' in found_functions}}

cdef cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, const cudaGraphEdgeData** edgeData_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamGetCaptureInfo_v3(stream, captureStatus_out, id_out, graph_out, dependencies_out, edgeData_out, numDependencies_out)

{{endif}}

{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}}

cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamUpdateCaptureDependencies(stream, dependencies, numDependencies, flags)

{{endif}}

{{if 'cudaStreamUpdateCaptureDependencies_v2' in found_functions}}

cdef cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t* dependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaStreamUpdateCaptureDependencies_v2(stream, dependencies, dependencyData, numDependencies, flags)

{{endif}}

{{if 'cudaEventCreate' in found_functions}}

cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventCreate(event)

{{endif}}

{{if 'cudaEventCreateWithFlags' in found_functions}}

cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventCreateWithFlags(event, flags)

{{endif}}

{{if 'cudaEventRecord' in found_functions}}

cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventRecord(event, stream)

{{endif}}

{{if 'cudaEventRecordWithFlags' in found_functions}}

cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventRecordWithFlags(event, stream, flags)

{{endif}}

{{if 'cudaEventQuery' in found_functions}}

cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventQuery(event)

{{endif}}

{{if 'cudaEventSynchronize' in found_functions}}

cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventSynchronize(event)

{{endif}}

{{if 'cudaEventDestroy' in found_functions}}

cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventDestroy(event)

{{endif}}

{{if 'cudaEventElapsedTime' in found_functions}}

cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventElapsedTime(ms, start, end)

{{endif}}

{{if 'cudaImportExternalMemory' in found_functions}}

cdef cudaError_t cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaImportExternalMemory(extMem_out, memHandleDesc)

{{endif}}

{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}}

cdef cudaError_t cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)

{{endif}}

{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}}

cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)

{{endif}}

{{if 'cudaDestroyExternalMemory' in found_functions}}

cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDestroyExternalMemory(extMem)

{{endif}}

{{if 'cudaImportExternalSemaphore' in found_functions}}

cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaImportExternalSemaphore(extSem_out, semHandleDesc)

{{endif}}

{{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}

cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaSignalExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream)

{{endif}}

{{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}

cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaWaitExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream)

{{endif}}

{{if 'cudaDestroyExternalSemaphore' in found_functions}}

cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDestroyExternalSemaphore(extSem)

{{endif}}

{{if 'cudaFuncSetCacheConfig' in found_functions}}

cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFuncSetCacheConfig(func, cacheConfig)

{{endif}}

{{if 'cudaFuncGetAttributes' in found_functions}}

cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFuncGetAttributes(attr, func)

{{endif}}

{{if 'cudaFuncSetAttribute' in found_functions}}

cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFuncSetAttribute(func, attr, value)

{{endif}}

{{if 'cudaLaunchHostFunc' in found_functions}}

cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaLaunchHostFunc(stream, fn, userData)

{{endif}}

{{if 'cudaFuncSetSharedMemConfig' in found_functions}}

cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFuncSetSharedMemConfig(func, config)

{{endif}}

{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}

cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)

{{endif}}

{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}}

cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)

{{endif}}

{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}

cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)

{{endif}}

{{if 'cudaMallocManaged' in found_functions}}

cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocManaged(devPtr, size, flags)

{{endif}}

{{if 'cudaMalloc' in found_functions}}

cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMalloc(devPtr, size)

{{endif}}

{{if 'cudaMallocHost' in found_functions}}

cdef cudaError_t cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocHost(ptr, size)

{{endif}}

{{if 'cudaMallocPitch' in found_functions}}

cdef cudaError_t cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocPitch(devPtr, pitch, width, height)

{{endif}}

{{if 'cudaMallocArray' in found_functions}}

cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocArray(array, desc, width, height, flags)

{{endif}}

{{if 'cudaFree' in found_functions}}

cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFree(devPtr)

{{endif}}

{{if 'cudaFreeHost' in found_functions}}

cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFreeHost(ptr)

{{endif}}

{{if 'cudaFreeArray' in found_functions}}

cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFreeArray(array)

{{endif}}

{{if 'cudaFreeMipmappedArray' in found_functions}}

cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFreeMipmappedArray(mipmappedArray)

{{endif}}

{{if 'cudaHostAlloc' in found_functions}}

cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaHostAlloc(pHost, size, flags)

{{endif}}

{{if 'cudaHostRegister' in found_functions}}

cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaHostRegister(ptr, size, flags)

{{endif}}

{{if 'cudaHostUnregister' in found_functions}}

cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaHostUnregister(ptr)

{{endif}}

{{if 'cudaHostGetDevicePointer' in found_functions}}

cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaHostGetDevicePointer(pDevice, pHost, flags)

{{endif}}

{{if 'cudaHostGetFlags' in found_functions}}

cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaHostGetFlags(pFlags, pHost)

{{endif}}

{{if 'cudaMalloc3D' in found_functions}}

cdef cudaError_t cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMalloc3D(pitchedDevPtr, extent)

{{endif}}

{{if 'cudaMalloc3DArray' in found_functions}}

cdef cudaError_t cudaMalloc3DArray(cudaArray_t* array, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMalloc3DArray(array, desc, extent, flags)

{{endif}}

{{if 'cudaMallocMipmappedArray' in found_functions}}

cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocMipmappedArray(mipmappedArray, desc, extent, numLevels, flags)

{{endif}}

{{if 'cudaGetMipmappedArrayLevel' in found_functions}}

cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level)

{{endif}}

{{if 'cudaMemcpy3D' in found_functions}}

cdef cudaError_t cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy3D(p)

{{endif}}

{{if 'cudaMemcpy3DPeer' in found_functions}}

cdef cudaError_t cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy3DPeer(p)

{{endif}}

{{if 'cudaMemcpy3DAsync' in found_functions}}

cdef cudaError_t cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy3DAsync(p, stream)

{{endif}}

{{if 'cudaMemcpy3DPeerAsync' in found_functions}}

cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy3DPeerAsync(p, stream)

{{endif}}

{{if 'cudaMemGetInfo' in found_functions}}

cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemGetInfo(free, total)

{{endif}}

{{if 'cudaArrayGetInfo' in found_functions}}

cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaArrayGetInfo(desc, extent, flags, array)

{{endif}}

{{if 'cudaArrayGetPlane' in found_functions}}

cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaArrayGetPlane(pPlaneArray, hArray, planeIdx)

{{endif}}

{{if 'cudaArrayGetMemoryRequirements' in found_functions}}

cdef cudaError_t cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaArrayGetMemoryRequirements(memoryRequirements, array, device)

{{endif}}

{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}}

cdef cudaError_t cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)

{{endif}}

{{if 'cudaArrayGetSparseProperties' in found_functions}}

cdef cudaError_t cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaArrayGetSparseProperties(sparseProperties, array)

{{endif}}

{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}}

cdef cudaError_t cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMipmappedArrayGetSparseProperties(sparseProperties, mipmap)

{{endif}}

{{if 'cudaMemcpy' in found_functions}}

cdef cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy(dst, src, count, kind)

{{endif}}

{{if 'cudaMemcpyPeer' in found_functions}}

cdef cudaError_t cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyPeer(dst, dstDevice, src, srcDevice, count)

{{endif}}

{{if 'cudaMemcpy2D' in found_functions}}

cdef cudaError_t cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2D(dst, dpitch, src, spitch, width, height, kind)

{{endif}}

{{if 'cudaMemcpy2DToArray' in found_functions}}

cdef cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2DToArray(dst, wOffset, hOffset, src, spitch, width, height, kind)

{{endif}}

{{if 'cudaMemcpy2DFromArray' in found_functions}}

cdef cudaError_t cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2DFromArray(dst, dpitch, src, wOffset, hOffset, width, height, kind)

{{endif}}

{{if 'cudaMemcpy2DArrayToArray' in found_functions}}

cdef cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2DArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind)

{{endif}}

{{if 'cudaMemcpyAsync' in found_functions}}

cdef cudaError_t cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyAsync(dst, src, count, kind, stream)

{{endif}}

{{if 'cudaMemcpyPeerAsync' in found_functions}}

cdef cudaError_t cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyPeerAsync(dst, dstDevice, src, srcDevice, count, stream)

{{endif}}

{{if 'cudaMemcpy2DAsync' in found_functions}}

cdef cudaError_t cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream)

{{endif}}

{{if 'cudaMemcpy2DToArrayAsync' in found_functions}}

cdef cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2DToArrayAsync(dst, wOffset, hOffset, src, spitch, width, height, kind, stream)

{{endif}}

{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}}

cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpy2DFromArrayAsync(dst, dpitch, src, wOffset, hOffset, width, height, kind, stream)

{{endif}}

{{if 'cudaMemset' in found_functions}}

cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemset(devPtr, value, count)

{{endif}}

{{if 'cudaMemset2D' in found_functions}}

cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemset2D(devPtr, pitch, value, width, height)

{{endif}}

{{if 'cudaMemset3D' in found_functions}}

cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemset3D(pitchedDevPtr, value, extent)

{{endif}}

{{if 'cudaMemsetAsync' in found_functions}}

cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemsetAsync(devPtr, value, count, stream)

{{endif}}

{{if 'cudaMemset2DAsync' in found_functions}}

cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemset2DAsync(devPtr, pitch, value, width, height, stream)

{{endif}}

{{if 'cudaMemset3DAsync' in found_functions}}

cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemset3DAsync(pitchedDevPtr, value, extent, stream)

{{endif}}

{{if 'cudaMemPrefetchAsync' in found_functions}}

cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPrefetchAsync(devPtr, count, dstDevice, stream)

{{endif}}

{{if 'cudaMemPrefetchAsync_v2' in found_functions}}

cdef cudaError_t cudaMemPrefetchAsync_v2(const void* devPtr, size_t count, cudaMemLocation location, unsigned int flags, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPrefetchAsync_v2(devPtr, count, location, flags, stream)

{{endif}}

{{if 'cudaMemAdvise' in found_functions}}

cdef cudaError_t cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemAdvise(devPtr, count, advice, device)

{{endif}}

{{if 'cudaMemAdvise_v2' in found_functions}}

cdef cudaError_t cudaMemAdvise_v2(const void* devPtr, size_t count, cudaMemoryAdvise advice, cudaMemLocation location) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemAdvise_v2(devPtr, count, advice, location)

{{endif}}

{{if 'cudaMemRangeGetAttribute' in found_functions}}

cdef cudaError_t cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemRangeGetAttribute(data, dataSize, attribute, devPtr, count)

{{endif}}

{{if 'cudaMemRangeGetAttributes' in found_functions}}

cdef cudaError_t cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count)

{{endif}}

{{if 'cudaMemcpyToArray' in found_functions}}

cdef cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyToArray(dst, wOffset, hOffset, src, count, kind)

{{endif}}

{{if 'cudaMemcpyFromArray' in found_functions}}

cdef cudaError_t cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyFromArray(dst, src, wOffset, hOffset, count, kind)

{{endif}}

{{if 'cudaMemcpyArrayToArray' in found_functions}}

cdef cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyArrayToArray(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind)

{{endif}}

{{if 'cudaMemcpyToArrayAsync' in found_functions}}

cdef cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyToArrayAsync(dst, wOffset, hOffset, src, count, kind, stream)

{{endif}}

{{if 'cudaMemcpyFromArrayAsync' in found_functions}}

cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemcpyFromArrayAsync(dst, src, wOffset, hOffset, count, kind, stream)

{{endif}}

{{if 'cudaMallocAsync' in found_functions}}

cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocAsync(devPtr, size, hStream)

{{endif}}

{{if 'cudaFreeAsync' in found_functions}}

cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaFreeAsync(devPtr, hStream)

{{endif}}

{{if 'cudaMemPoolTrimTo' in found_functions}}

cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolTrimTo(memPool, minBytesToKeep)

{{endif}}

{{if 'cudaMemPoolSetAttribute' in found_functions}}

cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolSetAttribute(memPool, attr, value)

{{endif}}

{{if 'cudaMemPoolGetAttribute' in found_functions}}

cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolGetAttribute(memPool, attr, value)

{{endif}}

{{if 'cudaMemPoolSetAccess' in found_functions}}

cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolSetAccess(memPool, descList, count)

{{endif}}

{{if 'cudaMemPoolGetAccess' in found_functions}}

cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolGetAccess(flags, memPool, location)

{{endif}}

{{if 'cudaMemPoolCreate' in found_functions}}

cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolCreate(memPool, poolProps)

{{endif}}

{{if 'cudaMemPoolDestroy' in found_functions}}

cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolDestroy(memPool)

{{endif}}

{{if 'cudaMallocFromPoolAsync' in found_functions}}

cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMallocFromPoolAsync(ptr, size, memPool, stream)

{{endif}}

{{if 'cudaMemPoolExportToShareableHandle' in found_functions}}

cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags)

{{endif}}

{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}}

cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags)

{{endif}}

{{if 'cudaMemPoolExportPointer' in found_functions}}

cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolExportPointer(exportData, ptr)

{{endif}}

{{if 'cudaMemPoolImportPointer' in found_functions}}

cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaMemPoolImportPointer(ptr, memPool, exportData)

{{endif}}

{{if 'cudaPointerGetAttributes' in found_functions}}

cdef cudaError_t cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaPointerGetAttributes(attributes, ptr)

{{endif}}

{{if 'cudaDeviceCanAccessPeer' in found_functions}}

cdef cudaError_t cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceCanAccessPeer(canAccessPeer, device, peerDevice)

{{endif}}

{{if 'cudaDeviceEnablePeerAccess' in found_functions}}

cdef cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceEnablePeerAccess(peerDevice, flags)

{{endif}}

{{if 'cudaDeviceDisablePeerAccess' in found_functions}}

cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceDisablePeerAccess(peerDevice)

{{endif}}

{{if 'cudaGraphicsUnregisterResource' in found_functions}}

cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsUnregisterResource(resource)

{{endif}}

{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}}

cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsResourceSetMapFlags(resource, flags)

{{endif}}

{{if 'cudaGraphicsMapResources' in found_functions}}

cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsMapResources(count, resources, stream)

{{endif}}

{{if 'cudaGraphicsUnmapResources' in found_functions}}

cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsUnmapResources(count, resources, stream)

{{endif}}

{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}}

cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsResourceGetMappedPointer(devPtr, size, resource)

{{endif}}

{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}}

cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel)

{{endif}}

{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}}

cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource)

{{endif}}

{{if 'cudaGetChannelDesc' in found_functions}}

cdef cudaError_t cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetChannelDesc(desc, array)

{{endif}}

{{if 'cudaCreateChannelDesc' in found_functions}}

cdef cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) nogil:
    return _cudaCreateChannelDesc(x, y, z, w, f)

{{endif}}

{{if 'cudaCreateTextureObject' in found_functions}}

cdef cudaError_t cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaCreateTextureObject(pTexObject, pResDesc, pTexDesc, pResViewDesc)

{{endif}}

{{if 'cudaDestroyTextureObject' in found_functions}}

cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDestroyTextureObject(texObject)

{{endif}}

{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}

cdef cudaError_t cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetTextureObjectResourceDesc(pResDesc, texObject)

{{endif}}

{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}

cdef cudaError_t cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetTextureObjectTextureDesc(pTexDesc, texObject)

{{endif}}

{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}

cdef cudaError_t cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetTextureObjectResourceViewDesc(pResViewDesc, texObject)

{{endif}}

{{if 'cudaCreateSurfaceObject' in found_functions}}

cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaCreateSurfaceObject(pSurfObject, pResDesc)

{{endif}}

{{if 'cudaDestroySurfaceObject' in found_functions}}

cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDestroySurfaceObject(surfObject)

{{endif}}

{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}

cdef cudaError_t cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetSurfaceObjectResourceDesc(pResDesc, surfObject)

{{endif}}

{{if 'cudaDriverGetVersion' in found_functions}}

cdef cudaError_t cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDriverGetVersion(driverVersion)

{{endif}}

{{if 'cudaRuntimeGetVersion' in found_functions}}

cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaRuntimeGetVersion(runtimeVersion)

{{endif}}

{{if 'cudaGraphCreate' in found_functions}}

cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphCreate(pGraph, flags)

{{endif}}

{{if 'cudaGraphAddKernelNode' in found_functions}}

cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)

{{endif}}

{{if 'cudaGraphKernelNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphKernelNodeGetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphKernelNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphKernelNodeSetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}

cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphKernelNodeCopyAttributes(hSrc, hDst)

{{endif}}

{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}

cdef cudaError_t cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphKernelNodeGetAttribute(hNode, attr, value_out)

{{endif}}

{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}

cdef cudaError_t cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphKernelNodeSetAttribute(hNode, attr, value)

{{endif}}

{{if 'cudaGraphAddMemcpyNode' in found_functions}}

cdef cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams)

{{endif}}

{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}

cdef cudaError_t cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies, dst, src, count, kind)

{{endif}}

{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemcpyNodeGetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemcpyNodeSetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}

cdef cudaError_t cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemcpyNodeSetParams1D(node, dst, src, count, kind)

{{endif}}

{{if 'cudaGraphAddMemsetNode' in found_functions}}

cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams)

{{endif}}

{{if 'cudaGraphMemsetNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemsetNodeGetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphMemsetNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemsetNodeSetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphAddHostNode' in found_functions}}

cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)

{{endif}}

{{if 'cudaGraphHostNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphHostNodeGetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphHostNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphHostNodeSetParams(node, pNodeParams)

{{endif}}

{{if 'cudaGraphAddChildGraphNode' in found_functions}}

cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph)

{{endif}}

{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}

cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphChildGraphNodeGetGraph(node, pGraph)

{{endif}}

{{if 'cudaGraphAddEmptyNode' in found_functions}}

cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies)

{{endif}}

{{if 'cudaGraphAddEventRecordNode' in found_functions}}

cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event)

{{endif}}

{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}

cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphEventRecordNodeGetEvent(node, event_out)

{{endif}}

{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}

cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphEventRecordNodeSetEvent(node, event)

{{endif}}

{{if 'cudaGraphAddEventWaitNode' in found_functions}}

cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event)

{{endif}}

{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}

cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphEventWaitNodeGetEvent(node, event_out)

{{endif}}

{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}

cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphEventWaitNodeSetEvent(node, event)

{{endif}}

{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}

cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)

{{endif}}

{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)

{{endif}}

{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)

{{endif}}

{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}

cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)

{{endif}}

{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)

{{endif}}

{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)

{{endif}}

{{if 'cudaGraphAddMemAllocNode' in found_functions}}

cdef cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)

{{endif}}

{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemAllocNodeGetParams(node, params_out)

{{endif}}

{{if 'cudaGraphAddMemFreeNode' in found_functions}}

cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr)

{{endif}}

{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}

cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphMemFreeNodeGetParams(node, dptr_out)

{{endif}}

{{if 'cudaDeviceGraphMemTrim' in found_functions}}

cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGraphMemTrim(device)

{{endif}}

{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}

cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceGetGraphMemAttribute(device, attr, value)

{{endif}}

{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}

cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaDeviceSetGraphMemAttribute(device, attr, value)

{{endif}}

{{if 'cudaGraphClone' in found_functions}}

cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphClone(pGraphClone, originalGraph)

{{endif}}

{{if 'cudaGraphNodeFindInClone' in found_functions}}

cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph)

{{endif}}

{{if 'cudaGraphNodeGetType' in found_functions}}

cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeGetType(node, pType)

{{endif}}

{{if 'cudaGraphGetNodes' in found_functions}}

cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphGetNodes(graph, nodes, numNodes)

{{endif}}

{{if 'cudaGraphGetRootNodes' in found_functions}}

cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes)

{{endif}}

{{if 'cudaGraphGetEdges' in found_functions}}

cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphGetEdges(graph, from_, to, numEdges)

{{endif}}

{{if 'cudaGraphGetEdges_v2' in found_functions}}

cdef cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, cudaGraphEdgeData* edgeData, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphGetEdges_v2(graph, from_, to, edgeData, numEdges)

{{endif}}

{{if 'cudaGraphNodeGetDependencies' in found_functions}}

cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeGetDependencies(node, pDependencies, pNumDependencies)

{{endif}}

{{if 'cudaGraphNodeGetDependencies_v2' in found_functions}}

cdef cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, cudaGraphEdgeData* edgeData, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeGetDependencies_v2(node, pDependencies, edgeData, pNumDependencies)

{{endif}}

{{if 'cudaGraphNodeGetDependentNodes' in found_functions}}

cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeGetDependentNodes(node, pDependentNodes, pNumDependentNodes)

{{endif}}

{{if 'cudaGraphNodeGetDependentNodes_v2' in found_functions}}

cdef cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, cudaGraphEdgeData* edgeData, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeGetDependentNodes_v2(node, pDependentNodes, edgeData, pNumDependentNodes)

{{endif}}

{{if 'cudaGraphAddDependencies' in found_functions}}

cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddDependencies(graph, from_, to, numDependencies)

{{endif}}

{{if 'cudaGraphAddDependencies_v2' in found_functions}}

cdef cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddDependencies_v2(graph, from_, to, edgeData, numDependencies)

{{endif}}

{{if 'cudaGraphRemoveDependencies' in found_functions}}

cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphRemoveDependencies(graph, from_, to, numDependencies)

{{endif}}

{{if 'cudaGraphRemoveDependencies_v2' in found_functions}}

cdef cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, const cudaGraphEdgeData* edgeData, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphRemoveDependencies_v2(graph, from_, to, edgeData, numDependencies)

{{endif}}

{{if 'cudaGraphDestroyNode' in found_functions}}

cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphDestroyNode(node)

{{endif}}

{{if 'cudaGraphInstantiate' in found_functions}}

cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphInstantiate(pGraphExec, graph, flags)

{{endif}}

{{if 'cudaGraphInstantiateWithFlags' in found_functions}}

cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphInstantiateWithFlags(pGraphExec, graph, flags)

{{endif}}

{{if 'cudaGraphInstantiateWithParams' in found_functions}}

cdef cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams* instantiateParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphInstantiateWithParams(pGraphExec, graph, instantiateParams)

{{endif}}

{{if 'cudaGraphExecGetFlags' in found_functions}}

cdef cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecGetFlags(graphExec, flags)

{{endif}}

{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams)

{{endif}}

{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams)

{{endif}}

{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}

cdef cudaError_t cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, count, kind)

{{endif}}

{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams)

{{endif}}

{{if 'cudaGraphExecHostNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams)

{{endif}}

{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph)

{{endif}}

{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}

cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)

{{endif}}

{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}

cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)

{{endif}}

{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)

{{endif}}

{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)

{{endif}}

{{if 'cudaGraphNodeSetEnabled' in found_functions}}

cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)

{{endif}}

{{if 'cudaGraphNodeGetEnabled' in found_functions}}

cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)

{{endif}}

{{if 'cudaGraphExecUpdate' in found_functions}}

cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo* resultInfo) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecUpdate(hGraphExec, hGraph, resultInfo)

{{endif}}

{{if 'cudaGraphUpload' in found_functions}}

cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphUpload(graphExec, stream)

{{endif}}

{{if 'cudaGraphLaunch' in found_functions}}

cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphLaunch(graphExec, stream)

{{endif}}

{{if 'cudaGraphExecDestroy' in found_functions}}

cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecDestroy(graphExec)

{{endif}}

{{if 'cudaGraphDestroy' in found_functions}}

cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphDestroy(graph)

{{endif}}

{{if 'cudaGraphDebugDotPrint' in found_functions}}

cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphDebugDotPrint(graph, path, flags)

{{endif}}

{{if 'cudaUserObjectCreate' in found_functions}}

cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)

{{endif}}

{{if 'cudaUserObjectRetain' in found_functions}}

cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaUserObjectRetain(object, count)

{{endif}}

{{if 'cudaUserObjectRelease' in found_functions}}

cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaUserObjectRelease(object, count)

{{endif}}

{{if 'cudaGraphRetainUserObject' in found_functions}}

cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphRetainUserObject(graph, object, count, flags)

{{endif}}

{{if 'cudaGraphReleaseUserObject' in found_functions}}

cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphReleaseUserObject(graph, object, count)

{{endif}}

{{if 'cudaGraphAddNode' in found_functions}}

cdef cudaError_t cudaGraphAddNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)

{{endif}}

{{if 'cudaGraphAddNode_v2' in found_functions}}

cdef cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, const cudaGraphEdgeData* dependencyData, size_t numDependencies, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphAddNode_v2(pGraphNode, graph, pDependencies, dependencyData, numDependencies, nodeParams)

{{endif}}

{{if 'cudaGraphNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphNodeSetParams(node, nodeParams)

{{endif}}

{{if 'cudaGraphExecNodeSetParams' in found_functions}}

cdef cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, cudaGraphNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphExecNodeSetParams(graphExec, node, nodeParams)

{{endif}}

{{if 'cudaGraphConditionalHandleCreate' in found_functions}}

cdef cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle* pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphConditionalHandleCreate(pHandle_out, graph, defaultLaunchValue, flags)

{{endif}}

{{if 'cudaGetDriverEntryPoint' in found_functions}}

cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetDriverEntryPoint(symbol, funcPtr, flags, driverStatus)

{{endif}}

{{if 'cudaGetDriverEntryPointByVersion' in found_functions}}

cdef cudaError_t cudaGetDriverEntryPointByVersion(const char* symbol, void** funcPtr, unsigned int cudaVersion, unsigned long long flags, cudaDriverEntryPointQueryResult* driverStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetDriverEntryPointByVersion(symbol, funcPtr, cudaVersion, flags, driverStatus)

{{endif}}

{{if 'cudaGetExportTable' in found_functions}}

cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetExportTable(ppExportTable, pExportTableId)

{{endif}}

{{if 'cudaGetKernel' in found_functions}}

cdef cudaError_t cudaGetKernel(cudaKernel_t* kernelPtr, const void* entryFuncAddr) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGetKernel(kernelPtr, entryFuncAddr)

{{endif}}

{{if 'make_cudaPitchedPtr' in found_functions}}

cdef cudaPitchedPtr make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) nogil:
    return _make_cudaPitchedPtr(d, p, xsz, ysz)

{{endif}}

{{if 'make_cudaPos' in found_functions}}

cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) nogil:
    return _make_cudaPos(x, y, z)

{{endif}}

{{if 'make_cudaExtent' in found_functions}}

cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil:
    return _make_cudaExtent(w, h, d)

{{endif}}

{{if True}}

cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsEGLRegisterImage(pCudaResource, image, flags)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamConsumerConnect(conn, eglStream)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamConsumerConnectWithFlags(conn, eglStream, flags)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamConsumerDisconnect(conn)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamProducerConnect(conn, eglStream, width, height)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamProducerDisconnect(conn)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamProducerPresentFrame(conn, eglframe, pStream)

{{endif}}

{{if True}}

cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEGLStreamProducerReturnFrame(conn, eglframe, pStream)

{{endif}}

{{if True}}

cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel)

{{endif}}

{{if True}}

cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaEventCreateFromEGLSync(phEvent, eglSync, flags)

{{endif}}

{{if True}}

cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaProfilerStart()

{{endif}}

{{if True}}

cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaProfilerStop()

{{endif}}

{{if True}}

cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGLGetDevices(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)

{{endif}}

{{if True}}

cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsGLRegisterImage(resource, image, target, flags)

{{endif}}

{{if True}}

cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsGLRegisterBuffer(resource, buffer, flags)

{{endif}}

{{if True}}

cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaVDPAUGetDevice(device, vdpDevice, vdpGetProcAddress)

{{endif}}

{{if True}}

cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaVDPAUSetVDPAUDevice(device, vdpDevice, vdpGetProcAddress)

{{endif}}

{{if True}}

cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsVDPAURegisterVideoSurface(resource, vdpSurface, flags)

{{endif}}

{{if True}}

cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _cudaGraphicsVDPAURegisterOutputSurface(resource, vdpSurface, flags)

{{endif}}

{{if True}}

cdef cudaError_t getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
    return _getLocalRuntimeVersion(runtimeVersion)

{{endif}}