diff --git a/CMakeLists.txt b/CMakeLists.txt
index 79764dd5e0bc11dae912bbba1dcc6d8443b2ec70..7b2d187f622294bd2c798f03b4190765068eb958 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,6 +39,9 @@ option(MGE_DISABLE_FLOAT16 "Disable MegEngine float16 support." OFF)
 option(MGE_WITH_CUDA "Enable MegEngine CUDA support." ON)
 option(MGE_CUDA_USE_STATIC "Enable MegEngine CUDA static linking." ON)
 option(MGE_WITH_TRT "Build MegEngine with TensorRT." ON)
+option(MGE_WITH_CUDA_STUB "Build MegEngine with CUDA stub." ON)
+option(MGE_WITH_NVRTC_STUB "Build MegEngine with NVRTC stub." OFF)
+option(MGE_WITH_CUDNN_SHARED "Build MegEngine with CUDNN shared." OFF)
 option(MGE_USE_SYSTEM_LIB "Build MegEngine with system libraries." OFF)
 option(MGB_WITH_FLATBUFFERS "Build MegBrain with FlatBuffers serialization support." ON)
 option(MGE_WITH_CAMBRICON "Build MegEngine with Cambricon support" OFF)
@@ -55,6 +58,14 @@ option(MGE_BUILD_SDK "Build load_and_run" ON)
 option(MGE_INFERENCE_ONLY "Build inference only library." OFF)
 option(MGE_WITH_MKLDNN "Enable Intel MKL_DNN support," ON)
 option(MGE_WITH_ROCM "Enable ROCM support" OFF)
+option(MGE_WITH_LARGE_ARCHIVE "Enable big archive link support" OFF)
+
+
+if(MGE_WITH_NVRTC_STUB OR MGE_WITH_CUDA_STUB)
+    set(MGE_WITH_ANY_CUDA_STUB ON)
+else()
+    set(MGE_WITH_ANY_CUDA_STUB OFF)
+endif()
 
 if(NOT ${MGE_BIN_REDUCE} STREQUAL "")
     message(STATUS "build with BIN REDUCE")
@@ -205,14 +216,24 @@ else()
     endif()
 endif()
 
+if(MGE_WITH_CUDA)
+include(cmake/cudnn.cmake)
+    if(MGE_CUDA_USE_STATIC AND ("${CUDNN_VERSION}" VERSION_GREATER "8.0.0" OR "${CUDNN_VERSION}" VERSION_EQUAL "8.0.0") AND (NOT MGE_WITH_CUDNN_SHARED))
+        message(WARNING "Static link CUDNN8 will auto enable MGE_WITH_LARGE_ARCHIVE=ON")
+        set(MGE_WITH_LARGE_ARCHIVE ON)
+    endif()
+endif()
 CHECK_CXX_COMPILER_FLAG(-fuse-ld=gold CXX_SUPPORT_GOLD)
-if(CXX_SUPPORT_GOLD AND NOT ANDROID AND NOT APPLE AND NOT MSVC AND NOT WIN32)
+if(MGE_WITH_LARGE_ARCHIVE)
+    message(STATUS "Set -mcmodel=large and disable -fuse-ld=gold")
+    set(MGE_COMMON_LINKER_FLAGS "-mcmodel=large")
+elseif(CXX_SUPPORT_GOLD AND NOT ANDROID AND NOT APPLE AND NOT MSVC AND NOT WIN32 AND NOT MGE_WITH_LARGE_ARCHIVE)
     message(STATUS "Using GNU gold linker.")
-    set(MGE_COMMON_LINKER_FLAGS "-fuse-ld=gold")
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MGE_COMMON_LINKER_FLAGS}")
-    set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MGE_COMMON_LINKER_FLAGS}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MGE_COMMON_LINKER_FLAGS}")
+    set(MGE_COMMON_LINKER_FLAGS "-fuse-ld=gold")    
 endif()
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MGE_COMMON_LINKER_FLAGS}")
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MGE_COMMON_LINKER_FLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MGE_COMMON_LINKER_FLAGS}")
 
 if(NOT MGE_WITH_JIT)
     if(MGE_WITH_HALIDE)
@@ -353,11 +374,28 @@ if(MGE_WITH_CUDA)
     if(NOT MGE_ENABLE_EXCEPTIONS)
         set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler -fno-exceptions")
     endif()
-
     if(NOT MGE_CUDA_GENCODE)
         if(${MGE_ARCH} STREQUAL "x86_64" OR ${MGE_ARCH} STREQUAL "i386")
             set(MEGDNN_THREADS_512 0)
-            if(${CMAKE_CUDA_COMPILER_VERSION} VERSION_GREATER "10.0.0" OR ${CMAKE_CUDA_COMPILER_VERSION} VERSION_EQUAL "10.0.0")
+            if(MGE_WITH_CUDA AND MGE_CUDA_USE_STATIC AND ("${CUDNN_VERSION}" VERSION_GREATER "8.0.0" OR "${CUDNN_VERSION}" VERSION_EQUAL "8.0.0") AND (NOT MGE_WITH_CUDNN_SHARED))
+                message(WARNING "Static link CUDNN8 with many sm is unworkable, we only enable sm61 sm70 sm75 by default, and enable MGE_WITH_LARGE_ARCHIVE=ON")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_61,code=sm_61")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_70,code=sm_70")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_75,code=sm_75")
+            elseif(${CMAKE_CUDA_COMPILER_VERSION} VERSION_GREATER "11.1.0" OR ${CMAKE_CUDA_COMPILER_VERSION} VERSION_EQUAL "11.1.0")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_61,code=sm_61")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_70,code=sm_70")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_75,code=sm_75")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_80,code=sm_80")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_86,code=sm_86")                
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_86,code=compute_86")
+            elseif(${CMAKE_CUDA_COMPILER_VERSION} VERSION_GREATER "11.0.0" OR ${CMAKE_CUDA_COMPILER_VERSION} VERSION_EQUAL "11.0.0")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_61,code=sm_61")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_70,code=sm_70")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_75,code=sm_75")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_80,code=sm_80")
+                set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_80,code=compute_80")
+            elseif(${CMAKE_CUDA_COMPILER_VERSION} VERSION_GREATER "10.0.0" OR ${CMAKE_CUDA_COMPILER_VERSION} VERSION_EQUAL "10.0.0")
                 set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_52,code=sm_52")
                 set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_60,code=sm_60")
                 set(MGE_CUDA_GENCODE "${MGE_CUDA_GENCODE} -gencode arch=compute_61,code=sm_61")
@@ -385,7 +423,6 @@ if(MGE_WITH_CUDA)
     endif()
 
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${MGE_CUDA_GENCODE}")
-    include(cmake/cudnn.cmake)
     if(MGE_WITH_TRT)
         include(cmake/tensorrt.cmake)
     endif()
@@ -394,12 +431,30 @@ if(MGE_WITH_CUDA)
             if(MSVC OR WIN32)
                 list(APPEND MGE_CUDA_LIBS ${TRT_LIBRARY} ${CUDNN_LIBRARY})
                 message(STATUS "windows TRT_LIBRARY: ${TRT_LIBRARY}")
+            else()                
+                if(TensorRT_VERSION_MAJOR GREATER_EQUAL 7)
+                    list(APPEND MGE_CUDA_LIBS -Wl,--whole-archive libnvinfer myelin_compiler_static myelin_executor_static myelin_pattern_runtime_static myelin_pattern_library_static -Wl,--no-whole-archive)
+                else()
+                    list(APPEND MGE_CUDA_LIBS -Wl,--whole-archive libnvinfer -Wl,--no-whole-archive)
+                endif()                
+            endif()
+        endif()
+        
+        if("${CUDNN_VERSION}" STREQUAL "7.5.0")
+            if(MSVC OR WIN32)
                 message(STATUS "windows CUDNN_LIBRARY: ${CUDNN_LIBRARY}")
+                list(APPEND MGE_CUDA_LIBS ${CUDNN_LIBRARY})
             else()
-                list(APPEND MGE_CUDA_LIBS -Wl,--whole-archive libnvinfer libcudnn -Wl,--no-whole-archive)
+                message(STATUS "cudnn 7.5.0 has bug in cudnnConvolutionBiasActivationForward, need --whole-archive to workaround, ref https://docs.nvidia.com/deeplearning/cudnn/release-notes/rel_7xx.html")
+                list(APPEND MGE_CUDA_LIBS -Wl,--whole-archive libcudnn -Wl,--no-whole-archive)
             endif()
         else()
-            list(APPEND MGE_CUDA_LIBS -Wl,--whole-archive libcudnn -Wl,--no-whole-archive)
+            if(MSVC OR WIN32)
+                message(STATUS "windows CUDNN_LIBRARY: ${CUDNN_LIBRARY}")
+                list(APPEND MGE_CUDA_LIBS ${CUDNN_LIBRARY})
+            else()
+                list(APPEND MGE_CUDA_LIBS libcudnn)
+            endif()
         endif()
         if(MSVC OR WIN32)
             list(APPEND MGE_CUDA_LIBS cusolver.lib cublas.lib curand.lib cudart_static.lib cusparse.lib)
@@ -447,15 +502,37 @@ if(MGE_WITH_CUDA)
         if(${CMAKE_CUDA_COMPILER_VERSION} VERSION_GREATER "10.1.0" OR ${CMAKE_CUDA_COMPILER_VERSION} VERSION_EQUAL "10.1.0")
             list(APPEND MGE_CUDA_LIBS cublasLt cusolver cublas curand)
         endif()
+        list(APPEND MGE_CUDA_LIBS cudart)
+    endif()
+
+    if(NOT MGE_WITH_CUDA_STUB)
+        if(MSVC OR WIN32)
+            list(APPEND MGE_CUDA_LIBS cuda.lib)
+        else()
+            list(APPEND MGE_CUDA_LIBS cuda)
+        endif()
+    endif()
+
+    if(NOT MGE_WITH_NVRTC_STUB)
+        if(MSVC OR WIN32)
+            list(APPEND MGE_CUDA_LIBS nvrtc.lib)
+        else()
+            list(APPEND MGE_CUDA_LIBS nvrtc)
+        endif()
+    endif()
+
+    if(MGE_WITH_ANY_CUDA_STUB)
+        add_subdirectory(dnn/cuda-stub)
+        list(APPEND MGE_CUDA_LIBS cuda-stub)
     endif()
 
-    add_subdirectory(dnn/cuda-stub)
     if(MSVC OR WIN32)
-        list(APPEND MGE_CUDA_LIBS nvrtc.lib cuda-stub)
+        list(APPEND MGE_CUDA_LIBS nvrtc.lib)
     else()
-        list(APPEND MGE_CUDA_LIBS nvrtc cuda-stub nvToolsExt)
+        list(APPEND MGE_CUDA_LIBS nvToolsExt)
     endif()
-    set(MGE_CUDA_LIBS "${MGE_CUDA_LIBS}")
+    
+    set(MGE_CUDA_LIBS "${MGE_CUDA_LIBS} -lrt")
 endif()
 
 if(MGE_WITH_CAMBRICON)
@@ -800,6 +877,9 @@ if(TARGET _imperative_rt)
         COMMAND ${CMAKE_COMMAND} -E create_symlink
           ${CMAKE_CURRENT_BINARY_DIR}/imperative/python/${PACKAGE_NAME}/core/$<TARGET_FILE_NAME:${MODULE_NAME}>
           ${CMAKE_CURRENT_SOURCE_DIR}/imperative/python/${PACKAGE_NAME}/core/$<TARGET_FILE_NAME:${MODULE_NAME}>
+        COMMAND ${CMAKE_COMMAND} -E create_symlink
+          ${CMAKE_CURRENT_BINARY_DIR}/imperative/python/${PACKAGE_NAME}/version.py
+          ${CMAKE_CURRENT_SOURCE_DIR}/imperative/python/${PACKAGE_NAME}/version.py
         DEPENDS _imperative_rt
         VERBATIM
     )
@@ -863,3 +943,9 @@ if(MGE_WITH_JIT_MLIR)
     add_subdirectory(tools/mlir/mgb-opt)
     add_subdirectory(tools/mlir/mgb-file-check)
 endif()
+
+if(MGE_WITH_CUDA AND MGE_CUDA_USE_STATIC AND("${CUDNN_VERSION}" VERSION_GREATER "8.0.0" OR "${CUDNN_VERSION}" VERSION_EQUAL "8.0.0") AND (NOT MGE_WITH_CUDNN_SHARED))
+    message(WARNING "Static link CUDNN8 with many sm is unworkable, please use -DMGE_WITH_CUDNN_SHARED=ON or -DMGE_WITH_LARGE_ARCHIVE=ON -DMGE_CUDA_GENCODE=\"-gencode arch=compute_70,code=sm_70 arch=compute_75,code=sm_75\" ")
+    message(WARNING "Static link CUDNN8 with many sm is unworkable, please use -DMGE_WITH_CUDNN_SHARED=ON or -DMGE_WITH_LARGE_ARCHIVE=ON -DMGE_CUDA_GENCODE=\"-gencode arch=compute_70,code=sm_70 arch=compute_75,code=sm_75\" ")
+    message(WARNING "Static link CUDNN8 with many sm is unworkable, please use -DMGE_WITH_CUDNN_SHARED=ON or -DMGE_WITH_LARGE_ARCHIVE=ON -DMGE_CUDA_GENCODE=\"-gencode arch=compute_70,code=sm_70 arch=compute_75,code=sm_75\" ")
+endif()
\ No newline at end of file
diff --git a/cmake/cudnn.cmake b/cmake/cudnn.cmake
index 3fd428033eebbf5edd0dc9f30e348df28250901f..3b037c3cc695612a85f6c5e9b444857b8e94096f 100644
--- a/cmake/cudnn.cmake
+++ b/cmake/cudnn.cmake
@@ -11,7 +11,7 @@ if("${CUDNN_ROOT_DIR}" STREQUAL "" AND NOT "$ENV{CUDNN_ROOT_DIR}"  STREQUAL "")
     set(CUDNN_ROOT_DIR $ENV{CUDNN_ROOT_DIR})
 endif()
 
-if(MGE_CUDA_USE_STATIC)
+if(MGE_CUDA_USE_STATIC AND NOT MGE_WITH_CUDNN_SHARED)
     find_library(CUDNN_LIBRARY 
         NAMES libcudnn_static.a cudnn.lib
         PATHS $ENV{LD_LIBRARY_PATH} ${CUDNN_ROOT_DIR} ${PC_CUDNN_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}
@@ -42,7 +42,12 @@ if(CUDNN_INCLUDE_DIR STREQUAL "CUDNN_INCLUDE_DIR-NOTFOUND")
     message(FATAL_ERROR "Can not find CuDNN Library")
 endif()
 
-file(READ ${CUDNN_INCLUDE_DIR}/cudnn.h CUDNN_VERSION_FILE_CONTENTS)
+if(EXISTS ${CUDNN_INCLUDE_DIR}/cudnn_version.h)
+    file(READ ${CUDNN_INCLUDE_DIR}/cudnn_version.h CUDNN_VERSION_FILE_CONTENTS)
+else()
+    file(READ ${CUDNN_INCLUDE_DIR}/cudnn.h CUDNN_VERSION_FILE_CONTENTS)
+endif()
+
 string(REGEX MATCH "define CUDNN_MAJOR * +([0-9]+)"
     CUDNN_MAJOR_VERSION "${CUDNN_VERSION_FILE_CONTENTS}")
 string(REGEX REPLACE "define CUDNN_MAJOR * +([0-9]+)" "\\1"
@@ -55,7 +60,9 @@ string(REGEX MATCH "define CUDNN_PATCHLEVEL * +([0-9]+)"
     CUDNN_PATCH_VERSION "${CUDNN_VERSION_FILE_CONTENTS}")
 string(REGEX REPLACE "define CUDNN_PATCHLEVEL * +([0-9]+)" "\\1"
     CUDNN_PATCH_VERSION "${CUDNN_PATCH_VERSION}")  
-set(CUDNN_VERSION ${CUDNN_MAJOR_VERSION}.${CUDNN_MINOR_VERSION})
+set(CUDNN_VERSION ${CUDNN_MAJOR_VERSION}.${CUDNN_MINOR_VERSION}.${CUDNN_PATCH_VERSION})
+
+
 
 if(MGE_CUDA_USE_STATIC)
     add_library(libcudnn STATIC IMPORTED)
diff --git a/dnn/cuda-stub/CMakeLists.txt b/dnn/cuda-stub/CMakeLists.txt
index ac75d255e1e245f1ede340ab54bd3343699e75dd..05256b56e3f44c5287c65e191093479868e4c21a 100644
--- a/dnn/cuda-stub/CMakeLists.txt
+++ b/dnn/cuda-stub/CMakeLists.txt
@@ -1,11 +1,21 @@
-file (GLOB_RECURSE SOURCES src/*.cpp)
+file (GLOB_RECURSE CUDA_STUB src/libcuda.cpp)
+file (GLOB_RECURSE NVRTC_STUB src/libnvrtc.cpp)
+
+if(MGE_WITH_CUDA_STUB)
+    list(APPEND STUB_SRC ${CUDA_STUB})
+endif()
+
+if(MGE_WITH_NVRTC_STUB)
+    list(APPEND STUB_SRC ${NVRTC_STUB})
+endif()
 
 if(MSVC OR WIN32)
-    add_library (cuda-stub STATIC ${SOURCES})
+    add_library (cuda-stub STATIC ${STUB_SRC})
 else()
-    add_library (cuda-stub SHARED ${SOURCES})
+    add_library (cuda-stub SHARED ${STUB_SRC})
 endif()
-set_target_properties(cuda-stub PROPERTIES OUTPUT_NAME cuda)
+
+set_target_properties(cuda-stub PROPERTIES OUTPUT_NAME cuda_stub)
 target_compile_definitions(cuda-stub PRIVATE __CUDA_API_VERSION_INTERNAL)
 if (MSVC OR WIN32)
     target_link_libraries(cuda-stub PRIVATE -Wl,--no-undefined)
diff --git a/dnn/cuda-stub/src/dlopen_helper.h b/dnn/cuda-stub/src/dlopen_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..00a429d57041fd1f1719c00c3f99cd10040a55c3
--- /dev/null
+++ b/dnn/cuda-stub/src/dlopen_helper.h
@@ -0,0 +1,109 @@
+#if defined(_WIN32)
+#include <windows.h>
+#define RTLD_LAZY 0
+
+static void* dlopen(const char* file, int) {
+    return static_cast<void*>(LoadLibraryA(file));
+}
+
+static void* dlerror() {
+    const char* errmsg = "dlerror not aviable in windows";
+    return const_cast<char*>(errmsg);
+}
+
+static void* dlsym(void* handle, const char* name) {
+    FARPROC symbol = GetProcAddress((HMODULE)handle, name);
+    return reinterpret_cast<void*>(symbol);
+}
+
+#else
+#include <dlfcn.h>
+#include <unistd.h>
+#endif
+
+#include <sstream>
+#include <string>
+#include <vector>
+static std::vector<std::string> split_string(const std::string& s, char delim) {
+    std::vector<std::string> elems;
+    std::stringstream ss(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        elems.push_back(item);
+    }
+    return elems;
+}
+
+static std::vector<std::string> get_env_dir(const char* env_name) {
+    const char* env_p = std::getenv(env_name);
+    std::vector<std::string> env_dir;
+    if (env_p) {
+        env_dir = split_string(env_p, ':');
+    }
+    return env_dir;
+}
+
+static void* try_open_handle(std::vector<std::string> dir_vec,
+                             std::string default_so_name) {
+    void* handle = nullptr;
+    for (auto& tk_path : dir_vec) {
+        handle = dlopen((tk_path + "/" + default_so_name).c_str(), RTLD_LAZY);
+        if (handle) {
+            break;
+        }
+    }
+    return handle;
+}
+
+static void* try_open_handle(const char** so_vec, int nr_so) {
+    void* handle = nullptr;
+    for (int i = 0; i < nr_so; ++i) {
+        handle = dlopen(so_vec[i], RTLD_LAZY);
+        if (handle) {
+            break;
+        }
+    }
+    return handle;
+}
+
+static void* get_library_handle() {
+    std::vector<std::string> cuda_tk_dir = get_env_dir("CUDA_TK_PATH");
+    std::vector<std::string> ld_dir = get_env_dir("LD_LIBRARY_PATH");
+    void* handle = nullptr;
+    if (!handle) {
+        handle = try_open_handle(ld_dir, default_so_name);
+    }
+    if (!handle) {
+        handle = try_open_handle(cuda_tk_dir, default_so_name);
+    }
+    if (!handle) {
+        handle = try_open_handle(default_so_paths,
+                                 sizeof(default_so_paths) / sizeof(char*));
+    }
+    if (!handle) {
+        handle = try_open_handle(extra_so_paths,
+                                 sizeof(extra_so_paths) / sizeof(char*));
+    }
+    if (!handle) {
+        LOGE("Failed to load %s API library", g_default_api_name);
+        return nullptr;
+    }
+    return handle;
+}
+
+static void log_failed_load(int func_idx) {
+    LOGE("failed to load %s func: %s", g_default_api_name,
+         g_func_name[func_idx]);
+}
+
+static void* resolve_library_func(void* handle, const char* func) {
+    if (!handle) {
+        LOGE("%s handle should not be nullptr!", g_default_api_name);
+        return nullptr;
+    }
+    auto ret = dlsym(handle, func);
+    if (!ret) {
+        LOGE("failed to load %s func: %s", g_default_api_name, func);
+    }
+    return ret;
+}
diff --git a/dnn/cuda-stub/src/libcuda-wrap.h b/dnn/cuda-stub/src/libcuda-wrap_10.1.h
similarity index 80%
rename from dnn/cuda-stub/src/libcuda-wrap.h
rename to dnn/cuda-stub/src/libcuda-wrap_10.1.h
index a0954ad627e47f2a8c245f294009b0a44de8caf5..106ae99e2a7b89e569713d67095ccd8d6d5e82b9 100644
--- a/dnn/cuda-stub/src/libcuda-wrap.h
+++ b/dnn/cuda-stub/src/libcuda-wrap_10.1.h
@@ -67,2149 +67,2618 @@ static CUresult _WRAPLIB_API_CALL cuDeviceGetName_init(char *arg0, int arg1, CUd
 static CUresult _WRAPLIB_API_CALL cuDeviceGetName_error(char *, int, CUdevice) {
     return on_init_failed<CUresult >(6);
 }
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_init(CUuuid *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetUuid(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_error(CUuuid *, CUdevice) {
+    return on_init_failed<CUresult >(7);
+}
 static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_init(size_t *arg0, CUdevice arg1) {
     load_library();
     return cuDeviceTotalMem_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_error(size_t *, CUdevice) {
-    return on_init_failed<CUresult >(7);
+    return on_init_failed<CUresult >(8);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_init(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
     load_library();
     return cuDeviceGetAttribute(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_error(int *, CUdevice_attribute, CUdevice) {
-    return on_init_failed<CUresult >(8);
+    return on_init_failed<CUresult >(9);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_init(CUdevprop *arg0, CUdevice arg1) {
     load_library();
     return cuDeviceGetProperties(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_error(CUdevprop *, CUdevice) {
-    return on_init_failed<CUresult >(9);
+    return on_init_failed<CUresult >(10);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_init(int *arg0, int *arg1, CUdevice arg2) {
     load_library();
     return cuDeviceComputeCapability(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_error(int *, int *, CUdevice) {
-    return on_init_failed<CUresult >(10);
+    return on_init_failed<CUresult >(11);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_init(CUcontext *arg0, CUdevice arg1) {
     load_library();
     return cuDevicePrimaryCtxRetain(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_error(CUcontext *, CUdevice) {
-    return on_init_failed<CUresult >(11);
+    return on_init_failed<CUresult >(12);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_init(CUdevice arg0) {
     load_library();
     return cuDevicePrimaryCtxRelease(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_error(CUdevice) {
-    return on_init_failed<CUresult >(12);
+    return on_init_failed<CUresult >(13);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_init(CUdevice arg0, unsigned int arg1) {
     load_library();
     return cuDevicePrimaryCtxSetFlags(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_error(CUdevice, unsigned int) {
-    return on_init_failed<CUresult >(13);
+    return on_init_failed<CUresult >(14);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_init(CUdevice arg0, unsigned int *arg1, int *arg2) {
     load_library();
     return cuDevicePrimaryCtxGetState(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_error(CUdevice, unsigned int *, int *) {
-    return on_init_failed<CUresult >(14);
+    return on_init_failed<CUresult >(15);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_init(CUdevice arg0) {
     load_library();
     return cuDevicePrimaryCtxReset(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_error(CUdevice) {
-    return on_init_failed<CUresult >(15);
+    return on_init_failed<CUresult >(16);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
     load_library();
     return cuCtxCreate_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_error(CUcontext *, unsigned int, CUdevice) {
-    return on_init_failed<CUresult >(16);
+    return on_init_failed<CUresult >(17);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_init(CUcontext arg0) {
     load_library();
     return cuCtxDestroy_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_error(CUcontext) {
-    return on_init_failed<CUresult >(17);
+    return on_init_failed<CUresult >(18);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_init(CUcontext arg0) {
     load_library();
     return cuCtxPushCurrent_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_error(CUcontext) {
-    return on_init_failed<CUresult >(18);
+    return on_init_failed<CUresult >(19);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_init(CUcontext *arg0) {
     load_library();
     return cuCtxPopCurrent_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_error(CUcontext *) {
-    return on_init_failed<CUresult >(19);
+    return on_init_failed<CUresult >(20);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_init(CUcontext arg0) {
     load_library();
     return cuCtxSetCurrent(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_error(CUcontext) {
-    return on_init_failed<CUresult >(20);
+    return on_init_failed<CUresult >(21);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_init(CUcontext *arg0) {
     load_library();
     return cuCtxGetCurrent(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_error(CUcontext *) {
-    return on_init_failed<CUresult >(21);
+    return on_init_failed<CUresult >(22);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_init(CUdevice *arg0) {
     load_library();
     return cuCtxGetDevice(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_error(CUdevice *) {
-    return on_init_failed<CUresult >(22);
+    return on_init_failed<CUresult >(23);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_init(unsigned int *arg0) {
     load_library();
     return cuCtxGetFlags(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_error(unsigned int *) {
-    return on_init_failed<CUresult >(23);
+    return on_init_failed<CUresult >(24);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_init() {
     load_library();
     return cuCtxSynchronize();
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_error() {
-    return on_init_failed<CUresult >(24);
+    return on_init_failed<CUresult >(25);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_init(CUlimit arg0, size_t arg1) {
     load_library();
     return cuCtxSetLimit(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_error(CUlimit, size_t) {
-    return on_init_failed<CUresult >(25);
+    return on_init_failed<CUresult >(26);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_init(size_t *arg0, CUlimit arg1) {
     load_library();
     return cuCtxGetLimit(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_error(size_t *, CUlimit) {
-    return on_init_failed<CUresult >(26);
+    return on_init_failed<CUresult >(27);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_init(CUfunc_cache *arg0) {
     load_library();
     return cuCtxGetCacheConfig(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_error(CUfunc_cache *) {
-    return on_init_failed<CUresult >(27);
+    return on_init_failed<CUresult >(28);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_init(CUfunc_cache arg0) {
     load_library();
     return cuCtxSetCacheConfig(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_error(CUfunc_cache) {
-    return on_init_failed<CUresult >(28);
+    return on_init_failed<CUresult >(29);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_init(CUsharedconfig *arg0) {
     load_library();
     return cuCtxGetSharedMemConfig(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_error(CUsharedconfig *) {
-    return on_init_failed<CUresult >(29);
+    return on_init_failed<CUresult >(30);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_init(CUsharedconfig arg0) {
     load_library();
     return cuCtxSetSharedMemConfig(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_error(CUsharedconfig) {
-    return on_init_failed<CUresult >(30);
+    return on_init_failed<CUresult >(31);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_init(CUcontext arg0, unsigned int *arg1) {
     load_library();
     return cuCtxGetApiVersion(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_error(CUcontext, unsigned int *) {
-    return on_init_failed<CUresult >(31);
+    return on_init_failed<CUresult >(32);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_init(int *arg0, int *arg1) {
     load_library();
     return cuCtxGetStreamPriorityRange(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_error(int *, int *) {
-    return on_init_failed<CUresult >(32);
+    return on_init_failed<CUresult >(33);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxAttach_init(CUcontext *arg0, unsigned int arg1) {
     load_library();
     return cuCtxAttach(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxAttach_error(CUcontext *, unsigned int) {
-    return on_init_failed<CUresult >(33);
+    return on_init_failed<CUresult >(34);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDetach_init(CUcontext arg0) {
     load_library();
     return cuCtxDetach(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDetach_error(CUcontext) {
-    return on_init_failed<CUresult >(34);
+    return on_init_failed<CUresult >(35);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoad_init(CUmodule *arg0, const char *arg1) {
     load_library();
     return cuModuleLoad(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoad_error(CUmodule *, const char *) {
-    return on_init_failed<CUresult >(35);
+    return on_init_failed<CUresult >(36);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoadData_init(CUmodule *arg0, const void *arg1) {
     load_library();
     return cuModuleLoadData(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoadData_error(CUmodule *, const void *) {
-    return on_init_failed<CUresult >(36);
+    return on_init_failed<CUresult >(37);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_init(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
     load_library();
     return cuModuleLoadDataEx(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_error(CUmodule *, const void *, unsigned int, CUjit_option *, void **) {
-    return on_init_failed<CUresult >(37);
+    return on_init_failed<CUresult >(38);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_init(CUmodule *arg0, const void *arg1) {
     load_library();
     return cuModuleLoadFatBinary(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_error(CUmodule *, const void *) {
-    return on_init_failed<CUresult >(38);
+    return on_init_failed<CUresult >(39);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleUnload_init(CUmodule arg0) {
     load_library();
     return cuModuleUnload(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleUnload_error(CUmodule) {
-    return on_init_failed<CUresult >(39);
+    return on_init_failed<CUresult >(40);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_init(CUfunction *arg0, CUmodule arg1, const char *arg2) {
     load_library();
     return cuModuleGetFunction(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_error(CUfunction *, CUmodule, const char *) {
-    return on_init_failed<CUresult >(40);
+    return on_init_failed<CUresult >(41);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_init(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
     load_library();
     return cuModuleGetGlobal_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_error(CUdeviceptr *, size_t *, CUmodule, const char *) {
-    return on_init_failed<CUresult >(41);
+    return on_init_failed<CUresult >(42);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_init(CUtexref *arg0, CUmodule arg1, const char *arg2) {
     load_library();
     return cuModuleGetTexRef(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_error(CUtexref *, CUmodule, const char *) {
-    return on_init_failed<CUresult >(42);
+    return on_init_failed<CUresult >(43);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_init(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
     load_library();
     return cuModuleGetSurfRef(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_error(CUsurfref *, CUmodule, const char *) {
-    return on_init_failed<CUresult >(43);
+    return on_init_failed<CUresult >(44);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
     load_library();
     return cuLinkCreate_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
-    return on_init_failed<CUresult >(44);
+    return on_init_failed<CUresult >(45);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
     load_library();
     return cuLinkAddData_v2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
-    return on_init_failed<CUresult >(45);
+    return on_init_failed<CUresult >(46);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
     load_library();
     return cuLinkAddFile_v2(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
-    return on_init_failed<CUresult >(46);
+    return on_init_failed<CUresult >(47);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkComplete_init(CUlinkState arg0, void **arg1, size_t *arg2) {
     load_library();
     return cuLinkComplete(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkComplete_error(CUlinkState, void **, size_t *) {
-    return on_init_failed<CUresult >(47);
+    return on_init_failed<CUresult >(48);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkDestroy_init(CUlinkState arg0) {
     load_library();
     return cuLinkDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkDestroy_error(CUlinkState) {
-    return on_init_failed<CUresult >(48);
+    return on_init_failed<CUresult >(49);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_init(size_t *arg0, size_t *arg1) {
     load_library();
     return cuMemGetInfo_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_error(size_t *, size_t *) {
-    return on_init_failed<CUresult >(49);
+    return on_init_failed<CUresult >(50);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_init(CUdeviceptr *arg0, size_t arg1) {
     load_library();
     return cuMemAlloc_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_error(CUdeviceptr *, size_t) {
-    return on_init_failed<CUresult >(50);
+    return on_init_failed<CUresult >(51);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_init(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
     load_library();
     return cuMemAllocPitch_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_error(CUdeviceptr *, size_t *, size_t, size_t, unsigned int) {
-    return on_init_failed<CUresult >(51);
+    return on_init_failed<CUresult >(52);
 }
 static CUresult _WRAPLIB_API_CALL cuMemFree_v2_init(CUdeviceptr arg0) {
     load_library();
     return cuMemFree_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemFree_v2_error(CUdeviceptr) {
-    return on_init_failed<CUresult >(52);
+    return on_init_failed<CUresult >(53);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_init(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
     load_library();
     return cuMemGetAddressRange_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_error(CUdeviceptr *, size_t *, CUdeviceptr) {
-    return on_init_failed<CUresult >(53);
+    return on_init_failed<CUresult >(54);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_init(void **arg0, size_t arg1) {
     load_library();
     return cuMemAllocHost_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_error(void **, size_t) {
-    return on_init_failed<CUresult >(54);
+    return on_init_failed<CUresult >(55);
 }
 static CUresult _WRAPLIB_API_CALL cuMemFreeHost_init(void *arg0) {
     load_library();
     return cuMemFreeHost(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemFreeHost_error(void *) {
-    return on_init_failed<CUresult >(55);
+    return on_init_failed<CUresult >(56);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_init(void **arg0, size_t arg1, unsigned int arg2) {
     load_library();
     return cuMemHostAlloc(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_error(void **, size_t, unsigned int) {
-    return on_init_failed<CUresult >(56);
+    return on_init_failed<CUresult >(57);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_init(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
     load_library();
     return cuMemHostGetDevicePointer_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_error(CUdeviceptr *, void *, unsigned int) {
-    return on_init_failed<CUresult >(57);
+    return on_init_failed<CUresult >(58);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_init(unsigned int *arg0, void *arg1) {
     load_library();
     return cuMemHostGetFlags(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_error(unsigned int *, void *) {
-    return on_init_failed<CUresult >(58);
+    return on_init_failed<CUresult >(59);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_init(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
     load_library();
     return cuMemAllocManaged(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_error(CUdeviceptr *, size_t, unsigned int) {
-    return on_init_failed<CUresult >(59);
+    return on_init_failed<CUresult >(60);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_init(CUdevice *arg0, const char *arg1) {
     load_library();
     return cuDeviceGetByPCIBusId(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_error(CUdevice *, const char *) {
-    return on_init_failed<CUresult >(60);
+    return on_init_failed<CUresult >(61);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_init(char *arg0, int arg1, CUdevice arg2) {
     load_library();
     return cuDeviceGetPCIBusId(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_error(char *, int, CUdevice) {
-    return on_init_failed<CUresult >(61);
+    return on_init_failed<CUresult >(62);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_init(CUipcEventHandle *arg0, CUevent arg1) {
     load_library();
     return cuIpcGetEventHandle(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_error(CUipcEventHandle *, CUevent) {
-    return on_init_failed<CUresult >(62);
+    return on_init_failed<CUresult >(63);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_init(CUevent *arg0, CUipcEventHandle arg1) {
     load_library();
     return cuIpcOpenEventHandle(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_error(CUevent *, CUipcEventHandle) {
-    return on_init_failed<CUresult >(63);
+    return on_init_failed<CUresult >(64);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_init(CUipcMemHandle *arg0, CUdeviceptr arg1) {
     load_library();
     return cuIpcGetMemHandle(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_error(CUipcMemHandle *, CUdeviceptr) {
-    return on_init_failed<CUresult >(64);
+    return on_init_failed<CUresult >(65);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_init(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
     load_library();
     return cuIpcOpenMemHandle(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_error(CUdeviceptr *, CUipcMemHandle, unsigned int) {
-    return on_init_failed<CUresult >(65);
+    return on_init_failed<CUresult >(66);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_init(CUdeviceptr arg0) {
     load_library();
     return cuIpcCloseMemHandle(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_error(CUdeviceptr) {
-    return on_init_failed<CUresult >(66);
+    return on_init_failed<CUresult >(67);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_init(void *arg0, size_t arg1, unsigned int arg2) {
     load_library();
     return cuMemHostRegister_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_error(void *, size_t, unsigned int) {
-    return on_init_failed<CUresult >(67);
+    return on_init_failed<CUresult >(68);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_init(void *arg0) {
     load_library();
     return cuMemHostUnregister(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_error(void *) {
-    return on_init_failed<CUresult >(68);
+    return on_init_failed<CUresult >(69);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     load_library();
     return cuMemcpy_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(69);
+    return on_init_failed<CUresult >(70);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
     load_library();
     return cuMemcpyPeer_ptds(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
-    return on_init_failed<CUresult >(70);
+    return on_init_failed<CUresult >(71);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
     load_library();
     return cuMemcpyHtoD_v2_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_error(CUdeviceptr, const void *, size_t) {
-    return on_init_failed<CUresult >(71);
+    return on_init_failed<CUresult >(72);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
     load_library();
     return cuMemcpyDtoH_v2_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_error(void *, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(72);
+    return on_init_failed<CUresult >(73);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     load_library();
     return cuMemcpyDtoD_v2_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(73);
+    return on_init_failed<CUresult >(74);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
     load_library();
     return cuMemcpyDtoA_v2_ptds(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_error(CUarray, size_t, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(74);
+    return on_init_failed<CUresult >(75);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
     load_library();
     return cuMemcpyAtoD_v2_ptds(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_error(CUdeviceptr, CUarray, size_t, size_t) {
-    return on_init_failed<CUresult >(75);
+    return on_init_failed<CUresult >(76);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
     load_library();
     return cuMemcpyHtoA_v2_ptds(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_error(CUarray, size_t, const void *, size_t) {
-    return on_init_failed<CUresult >(76);
+    return on_init_failed<CUresult >(77);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
     load_library();
     return cuMemcpyAtoH_v2_ptds(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_error(void *, CUarray, size_t, size_t) {
-    return on_init_failed<CUresult >(77);
+    return on_init_failed<CUresult >(78);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemcpyAtoA_v2_ptds(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_error(CUarray, size_t, CUarray, size_t, size_t) {
-    return on_init_failed<CUresult >(78);
+    return on_init_failed<CUresult >(79);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
     load_library();
     return cuMemcpy2D_v2_ptds(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_error(const CUDA_MEMCPY2D *) {
-    return on_init_failed<CUresult >(79);
+    return on_init_failed<CUresult >(80);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
     load_library();
     return cuMemcpy2DUnaligned_v2_ptds(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_error(const CUDA_MEMCPY2D *) {
-    return on_init_failed<CUresult >(80);
+    return on_init_failed<CUresult >(81);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_init(const CUDA_MEMCPY3D *arg0) {
     load_library();
     return cuMemcpy3D_v2_ptds(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_error(const CUDA_MEMCPY3D *) {
-    return on_init_failed<CUresult >(81);
+    return on_init_failed<CUresult >(82);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_init(const CUDA_MEMCPY3D_PEER *arg0) {
     load_library();
     return cuMemcpy3DPeer_ptds(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_error(const CUDA_MEMCPY3D_PEER *) {
-    return on_init_failed<CUresult >(82);
+    return on_init_failed<CUresult >(83);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyAsync_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
-    return on_init_failed<CUresult >(83);
+    return on_init_failed<CUresult >(84);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemcpyPeerAsync_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
-    return on_init_failed<CUresult >(84);
+    return on_init_failed<CUresult >(85);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyHtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_error(CUdeviceptr, const void *, size_t, CUstream) {
-    return on_init_failed<CUresult >(85);
+    return on_init_failed<CUresult >(86);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyDtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_error(void *, CUdeviceptr, size_t, CUstream) {
-    return on_init_failed<CUresult >(86);
+    return on_init_failed<CUresult >(87);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyDtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
-    return on_init_failed<CUresult >(87);
+    return on_init_failed<CUresult >(88);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
     load_library();
     return cuMemcpyHtoAAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_error(CUarray, size_t, const void *, size_t, CUstream) {
-    return on_init_failed<CUresult >(88);
+    return on_init_failed<CUresult >(89);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
     load_library();
     return cuMemcpyAtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_error(void *, CUarray, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(89);
+    return on_init_failed<CUresult >(90);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy2DAsync_v2_ptsz(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_error(const CUDA_MEMCPY2D *, CUstream) {
-    return on_init_failed<CUresult >(90);
+    return on_init_failed<CUresult >(91);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy3DAsync_v2_ptsz(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_error(const CUDA_MEMCPY3D *, CUstream) {
-    return on_init_failed<CUresult >(91);
+    return on_init_failed<CUresult >(92);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy3DPeerAsync_ptsz(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
-    return on_init_failed<CUresult >(92);
+    return on_init_failed<CUresult >(93);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
     load_library();
     return cuMemsetD8_v2_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_error(CUdeviceptr, unsigned char, size_t) {
-    return on_init_failed<CUresult >(93);
+    return on_init_failed<CUresult >(94);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
     load_library();
     return cuMemsetD16_v2_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_error(CUdeviceptr, unsigned short, size_t) {
-    return on_init_failed<CUresult >(94);
+    return on_init_failed<CUresult >(95);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
     load_library();
     return cuMemsetD32_v2_ptds(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_error(CUdeviceptr, unsigned int, size_t) {
-    return on_init_failed<CUresult >(95);
+    return on_init_failed<CUresult >(96);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemsetD2D8_v2_ptds(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
-    return on_init_failed<CUresult >(96);
+    return on_init_failed<CUresult >(97);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemsetD2D16_v2_ptds(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
-    return on_init_failed<CUresult >(97);
+    return on_init_failed<CUresult >(98);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemsetD2D32_v2_ptds(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
-    return on_init_failed<CUresult >(98);
+    return on_init_failed<CUresult >(99);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemsetD8Async_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_error(CUdeviceptr, unsigned char, size_t, CUstream) {
-    return on_init_failed<CUresult >(99);
+    return on_init_failed<CUresult >(100);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemsetD16Async_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_error(CUdeviceptr, unsigned short, size_t, CUstream) {
-    return on_init_failed<CUresult >(100);
+    return on_init_failed<CUresult >(101);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemsetD32Async_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_error(CUdeviceptr, unsigned int, size_t, CUstream) {
-    return on_init_failed<CUresult >(101);
+    return on_init_failed<CUresult >(102);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemsetD2D8Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(102);
+    return on_init_failed<CUresult >(103);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemsetD2D16Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(103);
+    return on_init_failed<CUresult >(104);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemsetD2D32Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(104);
+    return on_init_failed<CUresult >(105);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
     load_library();
     return cuArrayCreate_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR *) {
-    return on_init_failed<CUresult >(105);
+    return on_init_failed<CUresult >(106);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_init(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
     load_library();
     return cuArrayGetDescriptor_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_error(CUDA_ARRAY_DESCRIPTOR *, CUarray) {
-    return on_init_failed<CUresult >(106);
+    return on_init_failed<CUresult >(107);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayDestroy_init(CUarray arg0) {
     load_library();
     return cuArrayDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayDestroy_error(CUarray) {
-    return on_init_failed<CUresult >(107);
+    return on_init_failed<CUresult >(108);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
     load_library();
     return cuArray3DCreate_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *) {
-    return on_init_failed<CUresult >(108);
+    return on_init_failed<CUresult >(109);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_init(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
     load_library();
     return cuArray3DGetDescriptor_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_error(CUDA_ARRAY3D_DESCRIPTOR *, CUarray) {
-    return on_init_failed<CUresult >(109);
+    return on_init_failed<CUresult >(110);
 }
 static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_init(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
     load_library();
     return cuMipmappedArrayCreate(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_error(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int) {
-    return on_init_failed<CUresult >(110);
+    return on_init_failed<CUresult >(111);
 }
 static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_init(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
     load_library();
     return cuMipmappedArrayGetLevel(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_error(CUarray *, CUmipmappedArray, unsigned int) {
-    return on_init_failed<CUresult >(111);
+    return on_init_failed<CUresult >(112);
 }
 static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_init(CUmipmappedArray arg0) {
     load_library();
     return cuMipmappedArrayDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_error(CUmipmappedArray) {
-    return on_init_failed<CUresult >(112);
+    return on_init_failed<CUresult >(113);
 }
 static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_init(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
     load_library();
     return cuPointerGetAttribute(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_error(void *, CUpointer_attribute, CUdeviceptr) {
-    return on_init_failed<CUresult >(113);
+    return on_init_failed<CUresult >(114);
 }
 static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
     load_library();
     return cuMemPrefetchAsync_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_error(CUdeviceptr, size_t, CUdevice, CUstream) {
-    return on_init_failed<CUresult >(114);
+    return on_init_failed<CUresult >(115);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAdvise_init(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
     load_library();
     return cuMemAdvise(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAdvise_error(CUdeviceptr, size_t, CUmem_advise, CUdevice) {
-    return on_init_failed<CUresult >(115);
+    return on_init_failed<CUresult >(116);
 }
 static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_init(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
     load_library();
     return cuMemRangeGetAttribute(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_error(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(116);
+    return on_init_failed<CUresult >(117);
 }
 static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_init(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
     load_library();
     return cuMemRangeGetAttributes(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_error(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(117);
+    return on_init_failed<CUresult >(118);
 }
 static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_init(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
     load_library();
     return cuPointerSetAttribute(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_error(const void *, CUpointer_attribute, CUdeviceptr) {
-    return on_init_failed<CUresult >(118);
+    return on_init_failed<CUresult >(119);
 }
 static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_init(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
     load_library();
     return cuPointerGetAttributes(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_error(unsigned int, CUpointer_attribute *, void **, CUdeviceptr) {
-    return on_init_failed<CUresult >(119);
+    return on_init_failed<CUresult >(120);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamCreate_init(CUstream *arg0, unsigned int arg1) {
     load_library();
     return cuStreamCreate(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamCreate_error(CUstream *, unsigned int) {
-    return on_init_failed<CUresult >(120);
+    return on_init_failed<CUresult >(121);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_init(CUstream *arg0, unsigned int arg1, int arg2) {
     load_library();
     return cuStreamCreateWithPriority(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_error(CUstream *, unsigned int, int) {
-    return on_init_failed<CUresult >(121);
+    return on_init_failed<CUresult >(122);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_init(CUstream arg0, int *arg1) {
     load_library();
     return cuStreamGetPriority_ptsz(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_error(CUstream, int *) {
-    return on_init_failed<CUresult >(122);
+    return on_init_failed<CUresult >(123);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_init(CUstream arg0, unsigned int *arg1) {
     load_library();
     return cuStreamGetFlags_ptsz(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_error(CUstream, unsigned int *) {
-    return on_init_failed<CUresult >(123);
+    return on_init_failed<CUresult >(124);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(125);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
     load_library();
     return cuStreamWaitEvent_ptsz(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_error(CUstream, CUevent, unsigned int) {
-    return on_init_failed<CUresult >(124);
+    return on_init_failed<CUresult >(126);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
     load_library();
     return cuStreamAddCallback_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_error(CUstream, CUstreamCallback, void *, unsigned int) {
-    return on_init_failed<CUresult >(125);
+    return on_init_failed<CUresult >(127);
 }
-static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_init(CUstream arg0, CUstreamCaptureMode arg1) {
     load_library();
-    return cuStreamAttachMemAsync_ptsz(arg0, arg1, arg2, arg3);
+    return cuStreamBeginCapture_v2_ptsz(arg0, arg1);
 }
-static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_error(CUstream, CUdeviceptr, size_t, unsigned int) {
-    return on_init_failed<CUresult >(126);
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(128);
 }
-static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_init(CUstream arg0) {
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_init(CUstreamCaptureMode *arg0) {
     load_library();
-    return cuStreamQuery_ptsz(arg0);
+    return cuThreadExchangeStreamCaptureMode(arg0);
 }
-static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_error(CUstream) {
-    return on_init_failed<CUresult >(127);
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_error(CUstreamCaptureMode *) {
+    return on_init_failed<CUresult >(129);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(130);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(131);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(132);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(133);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(134);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_init(CUstream arg0) {
     load_library();
     return cuStreamSynchronize_ptsz(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_error(CUstream) {
-    return on_init_failed<CUresult >(128);
+    return on_init_failed<CUresult >(135);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_init(CUstream arg0) {
     load_library();
     return cuStreamDestroy_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_error(CUstream) {
-    return on_init_failed<CUresult >(129);
+    return on_init_failed<CUresult >(136);
 }
 static CUresult _WRAPLIB_API_CALL cuEventCreate_init(CUevent *arg0, unsigned int arg1) {
     load_library();
     return cuEventCreate(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuEventCreate_error(CUevent *, unsigned int) {
-    return on_init_failed<CUresult >(130);
+    return on_init_failed<CUresult >(137);
 }
 static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_init(CUevent arg0, CUstream arg1) {
     load_library();
     return cuEventRecord_ptsz(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_error(CUevent, CUstream) {
-    return on_init_failed<CUresult >(131);
+    return on_init_failed<CUresult >(138);
 }
 static CUresult _WRAPLIB_API_CALL cuEventQuery_init(CUevent arg0) {
     load_library();
     return cuEventQuery(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuEventQuery_error(CUevent) {
-    return on_init_failed<CUresult >(132);
+    return on_init_failed<CUresult >(139);
 }
 static CUresult _WRAPLIB_API_CALL cuEventSynchronize_init(CUevent arg0) {
     load_library();
     return cuEventSynchronize(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuEventSynchronize_error(CUevent) {
-    return on_init_failed<CUresult >(133);
+    return on_init_failed<CUresult >(140);
 }
 static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_init(CUevent arg0) {
     load_library();
     return cuEventDestroy_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_error(CUevent) {
-    return on_init_failed<CUresult >(134);
+    return on_init_failed<CUresult >(141);
 }
 static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_init(float *arg0, CUevent arg1, CUevent arg2) {
     load_library();
     return cuEventElapsedTime(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_error(float *, CUevent, CUevent) {
-    return on_init_failed<CUresult >(135);
+    return on_init_failed<CUresult >(142);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_init(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalMemory(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_error(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(143);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_init(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedBuffer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_error(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *) {
+    return on_init_failed<CUresult >(144);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_error(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *) {
+    return on_init_failed<CUresult >(145);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_init(CUexternalMemory arg0) {
+    load_library();
+    return cuDestroyExternalMemory(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_error(CUexternalMemory) {
+    return on_init_failed<CUresult >(146);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_init(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalSemaphore(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_error(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(147);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(148);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(149);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_init(CUexternalSemaphore arg0) {
+    load_library();
+    return cuDestroyExternalSemaphore(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_error(CUexternalSemaphore) {
+    return on_init_failed<CUresult >(150);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     load_library();
     return cuStreamWaitValue32_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
-    return on_init_failed<CUresult >(136);
+    return on_init_failed<CUresult >(151);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(152);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     load_library();
     return cuStreamWriteValue32_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
-    return on_init_failed<CUresult >(137);
+    return on_init_failed<CUresult >(153);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(154);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
     load_library();
     return cuStreamBatchMemOp_ptsz(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
-    return on_init_failed<CUresult >(138);
+    return on_init_failed<CUresult >(155);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_init(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
     load_library();
     return cuFuncGetAttribute(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_error(int *, CUfunction_attribute, CUfunction) {
-    return on_init_failed<CUresult >(139);
+    return on_init_failed<CUresult >(156);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_init(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    load_library();
+    return cuFuncSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_error(CUfunction, CUfunction_attribute, int) {
+    return on_init_failed<CUresult >(157);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_init(CUfunction arg0, CUfunc_cache arg1) {
     load_library();
     return cuFuncSetCacheConfig(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_error(CUfunction, CUfunc_cache) {
-    return on_init_failed<CUresult >(140);
+    return on_init_failed<CUresult >(158);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_init(CUfunction arg0, CUsharedconfig arg1) {
     load_library();
     return cuFuncSetSharedMemConfig(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_error(CUfunction, CUsharedconfig) {
-    return on_init_failed<CUresult >(141);
+    return on_init_failed<CUresult >(159);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
     load_library();
     return cuLaunchKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
-    return on_init_failed<CUresult >(142);
+    return on_init_failed<CUresult >(160);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(161);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_init(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuLaunchCooperativeKernelMultiDevice(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_error(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(162);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(163);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_init(CUfunction arg0, int arg1, int arg2, int arg3) {
     load_library();
     return cuFuncSetBlockShape(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_error(CUfunction, int, int, int) {
-    return on_init_failed<CUresult >(143);
+    return on_init_failed<CUresult >(164);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_init(CUfunction arg0, unsigned int arg1) {
     load_library();
     return cuFuncSetSharedSize(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_error(CUfunction, unsigned int) {
-    return on_init_failed<CUresult >(144);
+    return on_init_failed<CUresult >(165);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetSize_init(CUfunction arg0, unsigned int arg1) {
     load_library();
     return cuParamSetSize(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetSize_error(CUfunction, unsigned int) {
-    return on_init_failed<CUresult >(145);
+    return on_init_failed<CUresult >(166);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSeti_init(CUfunction arg0, int arg1, unsigned int arg2) {
     load_library();
     return cuParamSeti(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSeti_error(CUfunction, int, unsigned int) {
-    return on_init_failed<CUresult >(146);
+    return on_init_failed<CUresult >(167);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetf_init(CUfunction arg0, int arg1, float arg2) {
     load_library();
     return cuParamSetf(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetf_error(CUfunction, int, float) {
-    return on_init_failed<CUresult >(147);
+    return on_init_failed<CUresult >(168);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetv_init(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
     load_library();
     return cuParamSetv(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetv_error(CUfunction, int, void *, unsigned int) {
-    return on_init_failed<CUresult >(148);
+    return on_init_failed<CUresult >(169);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunch_init(CUfunction arg0) {
     load_library();
     return cuLaunch(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunch_error(CUfunction) {
-    return on_init_failed<CUresult >(149);
+    return on_init_failed<CUresult >(170);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchGrid_init(CUfunction arg0, int arg1, int arg2) {
     load_library();
     return cuLaunchGrid(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchGrid_error(CUfunction, int, int) {
-    return on_init_failed<CUresult >(150);
+    return on_init_failed<CUresult >(171);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_init(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
     load_library();
     return cuLaunchGridAsync(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_error(CUfunction, int, int, CUstream) {
-    return on_init_failed<CUresult >(151);
+    return on_init_failed<CUresult >(172);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_init(CUfunction arg0, int arg1, CUtexref arg2) {
     load_library();
     return cuParamSetTexRef(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_error(CUfunction, int, CUtexref) {
-    return on_init_failed<CUresult >(152);
+    return on_init_failed<CUresult >(173);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_init(CUgraph *arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_error(CUgraph *, unsigned int) {
+    return on_init_failed<CUresult >(174);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddKernelNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(175);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_init(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_error(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(176);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_init(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_error(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(177);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemcpyNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(178);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_init(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_error(CUgraphNode, CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(179);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_error(CUgraphNode, const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(180);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemsetNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(181);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_init(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_error(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(182);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_error(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(183);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddHostNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(184);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_init(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_error(CUgraphNode, CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(185);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_init(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_error(CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(186);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    load_library();
+    return cuGraphAddChildGraphNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph) {
+    return on_init_failed<CUresult >(187);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_init(CUgraphNode arg0, CUgraph *arg1) {
+    load_library();
+    return cuGraphChildGraphNodeGetGraph(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_error(CUgraphNode, CUgraph *) {
+    return on_init_failed<CUresult >(188);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddEmptyNode(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(189);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_init(CUgraph *arg0, CUgraph arg1) {
+    load_library();
+    return cuGraphClone(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_error(CUgraph *, CUgraph) {
+    return on_init_failed<CUresult >(190);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_init(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    load_library();
+    return cuGraphNodeFindInClone(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_error(CUgraphNode *, CUgraphNode, CUgraph) {
+    return on_init_failed<CUresult >(191);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_init(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    load_library();
+    return cuGraphNodeGetType(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_error(CUgraphNode, CUgraphNodeType *) {
+    return on_init_failed<CUresult >(192);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(193);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetRootNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(194);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_init(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    load_library();
+    return cuGraphGetEdges(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_error(CUgraph, CUgraphNode *, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(195);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependencies(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(196);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependentNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(197);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(198);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphRemoveDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(199);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_init(CUgraphNode arg0) {
+    load_library();
+    return cuGraphDestroyNode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_error(CUgraphNode) {
+    return on_init_failed<CUresult >(200);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_init(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    load_library();
+    return cuGraphInstantiate(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_error(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t) {
+    return on_init_failed<CUresult >(201);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecKernelNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(202);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(203);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_init(CUgraphExec arg0) {
+    load_library();
+    return cuGraphExecDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_error(CUgraphExec) {
+    return on_init_failed<CUresult >(204);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_init(CUgraph arg0) {
+    load_library();
+    return cuGraphDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_error(CUgraph) {
+    return on_init_failed<CUresult >(205);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_init(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
     load_library();
     return cuOccupancyMaxActiveBlocksPerMultiprocessor(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_error(int *, CUfunction, int, size_t) {
-    return on_init_failed<CUresult >(153);
+    return on_init_failed<CUresult >(206);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
     load_library();
     return cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error(int *, CUfunction, int, size_t, unsigned int) {
-    return on_init_failed<CUresult >(154);
+    return on_init_failed<CUresult >(207);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
     load_library();
     return cuOccupancyMaxPotentialBlockSize(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int) {
-    return on_init_failed<CUresult >(155);
+    return on_init_failed<CUresult >(208);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
     load_library();
     return cuOccupancyMaxPotentialBlockSizeWithFlags(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
 }
 static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int) {
-    return on_init_failed<CUresult >(156);
+    return on_init_failed<CUresult >(209);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_init(CUtexref arg0, CUarray arg1, unsigned int arg2) {
     load_library();
     return cuTexRefSetArray(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_error(CUtexref, CUarray, unsigned int) {
-    return on_init_failed<CUresult >(157);
+    return on_init_failed<CUresult >(210);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_init(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
     load_library();
     return cuTexRefSetMipmappedArray(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_error(CUtexref, CUmipmappedArray, unsigned int) {
-    return on_init_failed<CUresult >(158);
+    return on_init_failed<CUresult >(211);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_init(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
     load_library();
     return cuTexRefSetAddress_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_error(size_t *, CUtexref, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(159);
+    return on_init_failed<CUresult >(212);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
     load_library();
     return cuTexRefSetAddress2D_v3(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(160);
+    return on_init_failed<CUresult >(213);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_init(CUtexref arg0, CUarray_format arg1, int arg2) {
     load_library();
     return cuTexRefSetFormat(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_error(CUtexref, CUarray_format, int) {
-    return on_init_failed<CUresult >(161);
+    return on_init_failed<CUresult >(214);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_init(CUtexref arg0, int arg1, CUaddress_mode arg2) {
     load_library();
     return cuTexRefSetAddressMode(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_error(CUtexref, int, CUaddress_mode) {
-    return on_init_failed<CUresult >(162);
+    return on_init_failed<CUresult >(215);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
     load_library();
     return cuTexRefSetFilterMode(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_error(CUtexref, CUfilter_mode) {
-    return on_init_failed<CUresult >(163);
+    return on_init_failed<CUresult >(216);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
     load_library();
     return cuTexRefSetMipmapFilterMode(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_error(CUtexref, CUfilter_mode) {
-    return on_init_failed<CUresult >(164);
+    return on_init_failed<CUresult >(217);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_init(CUtexref arg0, float arg1) {
     load_library();
     return cuTexRefSetMipmapLevelBias(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_error(CUtexref, float) {
-    return on_init_failed<CUresult >(165);
+    return on_init_failed<CUresult >(218);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_init(CUtexref arg0, float arg1, float arg2) {
     load_library();
     return cuTexRefSetMipmapLevelClamp(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_error(CUtexref, float, float) {
-    return on_init_failed<CUresult >(166);
+    return on_init_failed<CUresult >(219);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_init(CUtexref arg0, unsigned int arg1) {
     load_library();
     return cuTexRefSetMaxAnisotropy(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_error(CUtexref, unsigned int) {
-    return on_init_failed<CUresult >(167);
+    return on_init_failed<CUresult >(220);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_init(CUtexref arg0, float *arg1) {
     load_library();
     return cuTexRefSetBorderColor(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_error(CUtexref, float *) {
-    return on_init_failed<CUresult >(168);
+    return on_init_failed<CUresult >(221);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_init(CUtexref arg0, unsigned int arg1) {
     load_library();
     return cuTexRefSetFlags(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_error(CUtexref, unsigned int) {
-    return on_init_failed<CUresult >(169);
+    return on_init_failed<CUresult >(222);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_init(CUdeviceptr *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetAddress_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_error(CUdeviceptr *, CUtexref) {
-    return on_init_failed<CUresult >(170);
+    return on_init_failed<CUresult >(223);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_init(CUarray *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetArray(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_error(CUarray *, CUtexref) {
-    return on_init_failed<CUresult >(171);
+    return on_init_failed<CUresult >(224);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_init(CUmipmappedArray *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetMipmappedArray(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_error(CUmipmappedArray *, CUtexref) {
-    return on_init_failed<CUresult >(172);
+    return on_init_failed<CUresult >(225);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_init(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
     load_library();
     return cuTexRefGetAddressMode(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_error(CUaddress_mode *, CUtexref, int) {
-    return on_init_failed<CUresult >(173);
+    return on_init_failed<CUresult >(226);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetFilterMode(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_error(CUfilter_mode *, CUtexref) {
-    return on_init_failed<CUresult >(174);
+    return on_init_failed<CUresult >(227);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_init(CUarray_format *arg0, int *arg1, CUtexref arg2) {
     load_library();
     return cuTexRefGetFormat(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_error(CUarray_format *, int *, CUtexref) {
-    return on_init_failed<CUresult >(175);
+    return on_init_failed<CUresult >(228);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetMipmapFilterMode(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_error(CUfilter_mode *, CUtexref) {
-    return on_init_failed<CUresult >(176);
+    return on_init_failed<CUresult >(229);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_init(float *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetMipmapLevelBias(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_error(float *, CUtexref) {
-    return on_init_failed<CUresult >(177);
+    return on_init_failed<CUresult >(230);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_init(float *arg0, float *arg1, CUtexref arg2) {
     load_library();
     return cuTexRefGetMipmapLevelClamp(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_error(float *, float *, CUtexref) {
-    return on_init_failed<CUresult >(178);
+    return on_init_failed<CUresult >(231);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_init(int *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetMaxAnisotropy(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_error(int *, CUtexref) {
-    return on_init_failed<CUresult >(179);
+    return on_init_failed<CUresult >(232);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_init(float *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetBorderColor(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_error(float *, CUtexref) {
-    return on_init_failed<CUresult >(180);
+    return on_init_failed<CUresult >(233);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_init(unsigned int *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetFlags(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_error(unsigned int *, CUtexref) {
-    return on_init_failed<CUresult >(181);
+    return on_init_failed<CUresult >(234);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefCreate_init(CUtexref *arg0) {
     load_library();
     return cuTexRefCreate(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefCreate_error(CUtexref *) {
-    return on_init_failed<CUresult >(182);
+    return on_init_failed<CUresult >(235);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_init(CUtexref arg0) {
     load_library();
     return cuTexRefDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_error(CUtexref) {
-    return on_init_failed<CUresult >(183);
+    return on_init_failed<CUresult >(236);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_init(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
     load_library();
     return cuSurfRefSetArray(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_error(CUsurfref, CUarray, unsigned int) {
-    return on_init_failed<CUresult >(184);
+    return on_init_failed<CUresult >(237);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_init(CUarray *arg0, CUsurfref arg1) {
     load_library();
     return cuSurfRefGetArray(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_error(CUarray *, CUsurfref) {
-    return on_init_failed<CUresult >(185);
+    return on_init_failed<CUresult >(238);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_init(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
     load_library();
     return cuTexObjectCreate(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_error(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *) {
-    return on_init_failed<CUresult >(186);
+    return on_init_failed<CUresult >(239);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_init(CUtexObject arg0) {
     load_library();
     return cuTexObjectDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_error(CUtexObject) {
-    return on_init_failed<CUresult >(187);
+    return on_init_failed<CUresult >(240);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
     load_library();
     return cuTexObjectGetResourceDesc(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUtexObject) {
-    return on_init_failed<CUresult >(188);
+    return on_init_failed<CUresult >(241);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_init(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
     load_library();
     return cuTexObjectGetTextureDesc(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_error(CUDA_TEXTURE_DESC *, CUtexObject) {
-    return on_init_failed<CUresult >(189);
+    return on_init_failed<CUresult >(242);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_init(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
     load_library();
     return cuTexObjectGetResourceViewDesc(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_error(CUDA_RESOURCE_VIEW_DESC *, CUtexObject) {
-    return on_init_failed<CUresult >(190);
+    return on_init_failed<CUresult >(243);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_init(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
     load_library();
     return cuSurfObjectCreate(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_error(CUsurfObject *, const CUDA_RESOURCE_DESC *) {
-    return on_init_failed<CUresult >(191);
+    return on_init_failed<CUresult >(244);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_init(CUsurfObject arg0) {
     load_library();
     return cuSurfObjectDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_error(CUsurfObject) {
-    return on_init_failed<CUresult >(192);
+    return on_init_failed<CUresult >(245);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
     load_library();
     return cuSurfObjectGetResourceDesc(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUsurfObject) {
-    return on_init_failed<CUresult >(193);
+    return on_init_failed<CUresult >(246);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_init(int *arg0, CUdevice arg1, CUdevice arg2) {
     load_library();
     return cuDeviceCanAccessPeer(arg0, arg1, arg2);
 }
-static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_error(int *, CUdevice, CUdevice) {
-    return on_init_failed<CUresult >(194);
-}
-static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_init(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
-    load_library();
-    return cuDeviceGetP2PAttribute(arg0, arg1, arg2, arg3);
-}
-static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_error(int *, CUdevice_P2PAttribute, CUdevice, CUdevice) {
-    return on_init_failed<CUresult >(195);
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_error(int *, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(247);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_init(CUcontext arg0, unsigned int arg1) {
     load_library();
     return cuCtxEnablePeerAccess(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_error(CUcontext, unsigned int) {
-    return on_init_failed<CUresult >(196);
+    return on_init_failed<CUresult >(248);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_init(CUcontext arg0) {
     load_library();
     return cuCtxDisablePeerAccess(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_error(CUcontext) {
-    return on_init_failed<CUresult >(197);
+    return on_init_failed<CUresult >(249);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_init(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    load_library();
+    return cuDeviceGetP2PAttribute(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_error(int *, CUdevice_P2PAttribute, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(250);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_init(CUgraphicsResource arg0) {
     load_library();
     return cuGraphicsUnregisterResource(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_error(CUgraphicsResource) {
-    return on_init_failed<CUresult >(198);
+    return on_init_failed<CUresult >(251);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_init(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
     load_library();
     return cuGraphicsSubResourceGetMappedArray(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_error(CUarray *, CUgraphicsResource, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(199);
+    return on_init_failed<CUresult >(252);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
     load_library();
     return cuGraphicsResourceGetMappedMipmappedArray(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_error(CUmipmappedArray *, CUgraphicsResource) {
-    return on_init_failed<CUresult >(200);
+    return on_init_failed<CUresult >(253);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_init(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
     load_library();
     return cuGraphicsResourceGetMappedPointer_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_error(CUdeviceptr *, size_t *, CUgraphicsResource) {
-    return on_init_failed<CUresult >(201);
+    return on_init_failed<CUresult >(254);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_init(CUgraphicsResource arg0, unsigned int arg1) {
     load_library();
     return cuGraphicsResourceSetMapFlags_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_error(CUgraphicsResource, unsigned int) {
-    return on_init_failed<CUresult >(202);
+    return on_init_failed<CUresult >(255);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     load_library();
     return cuGraphicsMapResources_ptsz(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
-    return on_init_failed<CUresult >(203);
+    return on_init_failed<CUresult >(256);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     load_library();
     return cuGraphicsUnmapResources_ptsz(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
-    return on_init_failed<CUresult >(204);
+    return on_init_failed<CUresult >(257);
 }
 static CUresult _WRAPLIB_API_CALL cuGetExportTable_init(const void **arg0, const CUuuid *arg1) {
     load_library();
     return cuGetExportTable(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuGetExportTable_error(const void **, const CUuuid *) {
-    return on_init_failed<CUresult >(205);
+    return on_init_failed<CUresult >(258);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostRegister_init(void *arg0, size_t arg1, unsigned int arg2) {
     load_library();
     return cuMemHostRegister(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostRegister_error(void *, size_t, unsigned int) {
-    return on_init_failed<CUresult >(206);
+    return on_init_failed<CUresult >(259);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_init(CUgraphicsResource arg0, unsigned int arg1) {
     load_library();
     return cuGraphicsResourceSetMapFlags(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_error(CUgraphicsResource, unsigned int) {
-    return on_init_failed<CUresult >(207);
+    return on_init_failed<CUresult >(260);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkCreate_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
     load_library();
     return cuLinkCreate(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkCreate_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
-    return on_init_failed<CUresult >(208);
+    return on_init_failed<CUresult >(261);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddData_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
     load_library();
     return cuLinkAddData(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddData_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
-    return on_init_failed<CUresult >(209);
+    return on_init_failed<CUresult >(262);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddFile_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
     load_library();
     return cuLinkAddFile(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuLinkAddFile_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
-    return on_init_failed<CUresult >(210);
+    return on_init_failed<CUresult >(263);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
     load_library();
     return cuTexRefSetAddress2D_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(211);
+    return on_init_failed<CUresult >(264);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_init(unsigned int *arg0, CUdevice arg1) {
     load_library();
     return cuDeviceTotalMem(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_error(unsigned int *, CUdevice) {
-    return on_init_failed<CUresult >(212);
+    return on_init_failed<CUresult >(265);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxCreate_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
     load_library();
     return cuCtxCreate(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxCreate_error(CUcontext *, unsigned int, CUdevice) {
-    return on_init_failed<CUresult >(213);
+    return on_init_failed<CUresult >(266);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
     load_library();
     return cuModuleGetGlobal(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_error(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *) {
-    return on_init_failed<CUresult >(214);
+    return on_init_failed<CUresult >(267);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetInfo_init(unsigned int *arg0, unsigned int *arg1) {
     load_library();
     return cuMemGetInfo(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetInfo_error(unsigned int *, unsigned int *) {
-    return on_init_failed<CUresult >(215);
+    return on_init_failed<CUresult >(268);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAlloc_init(CUdeviceptr_v1 *arg0, unsigned int arg1) {
     load_library();
     return cuMemAlloc(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAlloc_error(CUdeviceptr_v1 *, unsigned int) {
-    return on_init_failed<CUresult >(216);
+    return on_init_failed<CUresult >(269);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
     load_library();
     return cuMemAllocPitch(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_error(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(217);
+    return on_init_failed<CUresult >(270);
 }
 static CUresult _WRAPLIB_API_CALL cuMemFree_init(CUdeviceptr_v1 arg0) {
     load_library();
     return cuMemFree(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemFree_error(CUdeviceptr_v1) {
-    return on_init_failed<CUresult >(218);
+    return on_init_failed<CUresult >(271);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
     load_library();
     return cuMemGetAddressRange(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_error(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1) {
-    return on_init_failed<CUresult >(219);
+    return on_init_failed<CUresult >(272);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocHost_init(void **arg0, unsigned int arg1) {
     load_library();
     return cuMemAllocHost(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemAllocHost_error(void **, unsigned int) {
-    return on_init_failed<CUresult >(220);
+    return on_init_failed<CUresult >(273);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_init(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
     load_library();
     return cuMemHostGetDevicePointer(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_error(CUdeviceptr_v1 *, void *, unsigned int) {
-    return on_init_failed<CUresult >(221);
+    return on_init_failed<CUresult >(274);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
     load_library();
     return cuMemcpyHtoD(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_error(CUdeviceptr_v1, const void *, unsigned int) {
-    return on_init_failed<CUresult >(222);
+    return on_init_failed<CUresult >(275);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
     load_library();
     return cuMemcpyDtoH(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_error(void *, CUdeviceptr_v1, unsigned int) {
-    return on_init_failed<CUresult >(223);
+    return on_init_failed<CUresult >(276);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
     load_library();
     return cuMemcpyDtoD(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int) {
-    return on_init_failed<CUresult >(224);
+    return on_init_failed<CUresult >(277);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_init(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
     load_library();
     return cuMemcpyDtoA(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_error(CUarray, unsigned int, CUdeviceptr_v1, unsigned int) {
-    return on_init_failed<CUresult >(225);
+    return on_init_failed<CUresult >(278);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_init(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
     load_library();
     return cuMemcpyAtoD(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_error(CUdeviceptr_v1, CUarray, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(226);
+    return on_init_failed<CUresult >(279);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
     load_library();
     return cuMemcpyHtoA(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_error(CUarray, unsigned int, const void *, unsigned int) {
-    return on_init_failed<CUresult >(227);
+    return on_init_failed<CUresult >(280);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
     load_library();
     return cuMemcpyAtoH(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_error(void *, CUarray, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(228);
+    return on_init_failed<CUresult >(281);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_init(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
     load_library();
     return cuMemcpyAtoA(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_error(CUarray, unsigned int, CUarray, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(229);
+    return on_init_failed<CUresult >(282);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
     load_library();
     return cuMemcpyHtoAAsync(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_error(CUarray, unsigned int, const void *, unsigned int, CUstream) {
-    return on_init_failed<CUresult >(230);
+    return on_init_failed<CUresult >(283);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
     load_library();
     return cuMemcpyAtoHAsync(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_error(void *, CUarray, unsigned int, unsigned int, CUstream) {
-    return on_init_failed<CUresult >(231);
+    return on_init_failed<CUresult >(284);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2D_init(const CUDA_MEMCPY2D_v1 *arg0) {
     load_library();
     return cuMemcpy2D(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2D_error(const CUDA_MEMCPY2D_v1 *) {
-    return on_init_failed<CUresult >(232);
+    return on_init_failed<CUresult >(285);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_init(const CUDA_MEMCPY2D_v1 *arg0) {
     load_library();
     return cuMemcpy2DUnaligned(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_error(const CUDA_MEMCPY2D_v1 *) {
-    return on_init_failed<CUresult >(233);
+    return on_init_failed<CUresult >(286);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3D_init(const CUDA_MEMCPY3D_v1 *arg0) {
     load_library();
     return cuMemcpy3D(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3D_error(const CUDA_MEMCPY3D_v1 *) {
-    return on_init_failed<CUresult >(234);
+    return on_init_failed<CUresult >(287);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
     load_library();
     return cuMemcpyHtoDAsync(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_error(CUdeviceptr_v1, const void *, unsigned int, CUstream) {
-    return on_init_failed<CUresult >(235);
+    return on_init_failed<CUresult >(288);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
     load_library();
     return cuMemcpyDtoHAsync(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_error(void *, CUdeviceptr_v1, unsigned int, CUstream) {
-    return on_init_failed<CUresult >(236);
+    return on_init_failed<CUresult >(289);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
     load_library();
     return cuMemcpyDtoDAsync(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream) {
-    return on_init_failed<CUresult >(237);
+    return on_init_failed<CUresult >(290);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_init(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy2DAsync(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_error(const CUDA_MEMCPY2D_v1 *, CUstream) {
-    return on_init_failed<CUresult >(238);
+    return on_init_failed<CUresult >(291);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_init(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy3DAsync(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_error(const CUDA_MEMCPY3D_v1 *, CUstream) {
-    return on_init_failed<CUresult >(239);
+    return on_init_failed<CUresult >(292);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8_init(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
     load_library();
     return cuMemsetD8(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8_error(CUdeviceptr_v1, unsigned char, unsigned int) {
-    return on_init_failed<CUresult >(240);
+    return on_init_failed<CUresult >(293);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16_init(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
     load_library();
     return cuMemsetD16(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16_error(CUdeviceptr_v1, unsigned short, unsigned int) {
-    return on_init_failed<CUresult >(241);
+    return on_init_failed<CUresult >(294);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
     load_library();
     return cuMemsetD32(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32_error(CUdeviceptr_v1, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(242);
+    return on_init_failed<CUresult >(295);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
     load_library();
     return cuMemsetD2D8(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_error(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(243);
+    return on_init_failed<CUresult >(296);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
     load_library();
     return cuMemsetD2D16(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_error(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(244);
+    return on_init_failed<CUresult >(297);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
     load_library();
     return cuMemsetD2D32(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_error(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int) {
-    return on_init_failed<CUresult >(245);
+    return on_init_failed<CUresult >(298);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayCreate_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
     load_library();
     return cuArrayCreate(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayCreate_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *) {
-    return on_init_failed<CUresult >(246);
+    return on_init_failed<CUresult >(299);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_init(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
     load_library();
     return cuArrayGetDescriptor(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_error(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray) {
-    return on_init_failed<CUresult >(247);
+    return on_init_failed<CUresult >(300);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DCreate_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
     load_library();
     return cuArray3DCreate(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DCreate_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *) {
-    return on_init_failed<CUresult >(248);
+    return on_init_failed<CUresult >(301);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_init(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
     load_library();
     return cuArray3DGetDescriptor(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_error(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray) {
-    return on_init_failed<CUresult >(249);
+    return on_init_failed<CUresult >(302);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_init(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
     load_library();
     return cuTexRefSetAddress(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_error(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int) {
-    return on_init_failed<CUresult >(250);
+    return on_init_failed<CUresult >(303);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
     load_library();
     return cuTexRefSetAddress2D(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int) {
-    return on_init_failed<CUresult >(251);
+    return on_init_failed<CUresult >(304);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_init(CUdeviceptr_v1 *arg0, CUtexref arg1) {
     load_library();
     return cuTexRefGetAddress(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_error(CUdeviceptr_v1 *, CUtexref) {
-    return on_init_failed<CUresult >(252);
+    return on_init_failed<CUresult >(305);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
     load_library();
     return cuGraphicsResourceGetMappedPointer(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_error(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource) {
-    return on_init_failed<CUresult >(253);
+    return on_init_failed<CUresult >(306);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDestroy_init(CUcontext arg0) {
     load_library();
     return cuCtxDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxDestroy_error(CUcontext) {
-    return on_init_failed<CUresult >(254);
+    return on_init_failed<CUresult >(307);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_init(CUcontext *arg0) {
     load_library();
     return cuCtxPopCurrent(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_error(CUcontext *) {
-    return on_init_failed<CUresult >(255);
+    return on_init_failed<CUresult >(308);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_init(CUcontext arg0) {
     load_library();
     return cuCtxPushCurrent(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_error(CUcontext) {
-    return on_init_failed<CUresult >(256);
+    return on_init_failed<CUresult >(309);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamDestroy_init(CUstream arg0) {
     load_library();
     return cuStreamDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamDestroy_error(CUstream) {
-    return on_init_failed<CUresult >(257);
+    return on_init_failed<CUresult >(310);
 }
 static CUresult _WRAPLIB_API_CALL cuEventDestroy_init(CUevent arg0) {
     load_library();
     return cuEventDestroy(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuEventDestroy_error(CUevent) {
-    return on_init_failed<CUresult >(258);
+    return on_init_failed<CUresult >(311);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
     load_library();
     return cuMemcpyHtoD_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_error(CUdeviceptr, const void *, size_t) {
-    return on_init_failed<CUresult >(259);
+    return on_init_failed<CUresult >(312);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
     load_library();
     return cuMemcpyDtoH_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_error(void *, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(260);
+    return on_init_failed<CUresult >(313);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     load_library();
     return cuMemcpyDtoD_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_error(CUdeviceptr, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(261);
+    return on_init_failed<CUresult >(314);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
     load_library();
     return cuMemcpyDtoA_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_error(CUarray, size_t, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(262);
+    return on_init_failed<CUresult >(315);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
     load_library();
     return cuMemcpyAtoD_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_error(CUdeviceptr, CUarray, size_t, size_t) {
-    return on_init_failed<CUresult >(263);
+    return on_init_failed<CUresult >(316);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
     load_library();
     return cuMemcpyHtoA_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_error(CUarray, size_t, const void *, size_t) {
-    return on_init_failed<CUresult >(264);
+    return on_init_failed<CUresult >(317);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
     load_library();
     return cuMemcpyAtoH_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_error(void *, CUarray, size_t, size_t) {
-    return on_init_failed<CUresult >(265);
+    return on_init_failed<CUresult >(318);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemcpyAtoA_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_error(CUarray, size_t, CUarray, size_t, size_t) {
-    return on_init_failed<CUresult >(266);
+    return on_init_failed<CUresult >(319);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
     load_library();
     return cuMemcpyHtoAAsync_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_error(CUarray, size_t, const void *, size_t, CUstream) {
-    return on_init_failed<CUresult >(267);
+    return on_init_failed<CUresult >(320);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
     load_library();
     return cuMemcpyAtoHAsync_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_error(void *, CUarray, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(268);
+    return on_init_failed<CUresult >(321);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_init(const CUDA_MEMCPY2D *arg0) {
     load_library();
     return cuMemcpy2D_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_error(const CUDA_MEMCPY2D *) {
-    return on_init_failed<CUresult >(269);
+    return on_init_failed<CUresult >(322);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_init(const CUDA_MEMCPY2D *arg0) {
     load_library();
     return cuMemcpy2DUnaligned_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_error(const CUDA_MEMCPY2D *) {
-    return on_init_failed<CUresult >(270);
+    return on_init_failed<CUresult >(323);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_init(const CUDA_MEMCPY3D *arg0) {
     load_library();
     return cuMemcpy3D_v2(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_error(const CUDA_MEMCPY3D *) {
-    return on_init_failed<CUresult >(271);
+    return on_init_failed<CUresult >(324);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyHtoDAsync_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_error(CUdeviceptr, const void *, size_t, CUstream) {
-    return on_init_failed<CUresult >(272);
+    return on_init_failed<CUresult >(325);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyDtoHAsync_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_error(void *, CUdeviceptr, size_t, CUstream) {
-    return on_init_failed<CUresult >(273);
+    return on_init_failed<CUresult >(326);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyDtoDAsync_v2(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
-    return on_init_failed<CUresult >(274);
+    return on_init_failed<CUresult >(327);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy2DAsync_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_error(const CUDA_MEMCPY2D *, CUstream) {
-    return on_init_failed<CUresult >(275);
+    return on_init_failed<CUresult >(328);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy3DAsync_v2(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_error(const CUDA_MEMCPY3D *, CUstream) {
-    return on_init_failed<CUresult >(276);
+    return on_init_failed<CUresult >(329);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
     load_library();
     return cuMemsetD8_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_error(CUdeviceptr, unsigned char, size_t) {
-    return on_init_failed<CUresult >(277);
+    return on_init_failed<CUresult >(330);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
     load_library();
     return cuMemsetD16_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_error(CUdeviceptr, unsigned short, size_t) {
-    return on_init_failed<CUresult >(278);
+    return on_init_failed<CUresult >(331);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
     load_library();
     return cuMemsetD32_v2(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_error(CUdeviceptr, unsigned int, size_t) {
-    return on_init_failed<CUresult >(279);
+    return on_init_failed<CUresult >(332);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemsetD2D8_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
-    return on_init_failed<CUresult >(280);
+    return on_init_failed<CUresult >(333);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemsetD2D16_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
-    return on_init_failed<CUresult >(281);
+    return on_init_failed<CUresult >(334);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
     load_library();
     return cuMemsetD2D32_v2(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
-    return on_init_failed<CUresult >(282);
+    return on_init_failed<CUresult >(335);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     load_library();
     return cuMemcpy(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy_error(CUdeviceptr, CUdeviceptr, size_t) {
-    return on_init_failed<CUresult >(283);
+    return on_init_failed<CUresult >(336);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemcpyAsync(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
-    return on_init_failed<CUresult >(284);
+    return on_init_failed<CUresult >(337);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
     load_library();
     return cuMemcpyPeer(arg0, arg1, arg2, arg3, arg4);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
-    return on_init_failed<CUresult >(285);
+    return on_init_failed<CUresult >(338);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemcpyPeerAsync(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
-    return on_init_failed<CUresult >(286);
+    return on_init_failed<CUresult >(339);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_init(const CUDA_MEMCPY3D_PEER *arg0) {
     load_library();
     return cuMemcpy3DPeer(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_error(const CUDA_MEMCPY3D_PEER *) {
-    return on_init_failed<CUresult >(287);
+    return on_init_failed<CUresult >(340);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
     load_library();
     return cuMemcpy3DPeerAsync(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
-    return on_init_failed<CUresult >(288);
+    return on_init_failed<CUresult >(341);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemsetD8Async(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_error(CUdeviceptr, unsigned char, size_t, CUstream) {
-    return on_init_failed<CUresult >(289);
+    return on_init_failed<CUresult >(342);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemsetD16Async(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_error(CUdeviceptr, unsigned short, size_t, CUstream) {
-    return on_init_failed<CUresult >(290);
+    return on_init_failed<CUresult >(343);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
     load_library();
     return cuMemsetD32Async(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_error(CUdeviceptr, unsigned int, size_t, CUstream) {
-    return on_init_failed<CUresult >(291);
+    return on_init_failed<CUresult >(344);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemsetD2D8Async(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(292);
+    return on_init_failed<CUresult >(345);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemsetD2D16Async(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(293);
+    return on_init_failed<CUresult >(346);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
     load_library();
     return cuMemsetD2D32Async(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
-    return on_init_failed<CUresult >(294);
+    return on_init_failed<CUresult >(347);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_init(CUstream arg0, int *arg1) {
     load_library();
     return cuStreamGetPriority(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_error(CUstream, int *) {
-    return on_init_failed<CUresult >(295);
+    return on_init_failed<CUresult >(348);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_init(CUstream arg0, unsigned int *arg1) {
     load_library();
     return cuStreamGetFlags(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_error(CUstream, unsigned int *) {
-    return on_init_failed<CUresult >(296);
+    return on_init_failed<CUresult >(349);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(350);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
     load_library();
     return cuStreamWaitEvent(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_error(CUstream, CUevent, unsigned int) {
-    return on_init_failed<CUresult >(297);
+    return on_init_failed<CUresult >(351);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
     load_library();
     return cuStreamAddCallback(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_error(CUstream, CUstreamCallback, void *, unsigned int) {
-    return on_init_failed<CUresult >(298);
+    return on_init_failed<CUresult >(352);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
     load_library();
     return cuStreamAttachMemAsync(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_error(CUstream, CUdeviceptr, size_t, unsigned int) {
-    return on_init_failed<CUresult >(299);
+    return on_init_failed<CUresult >(353);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamQuery_init(CUstream arg0) {
     load_library();
     return cuStreamQuery(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamQuery_error(CUstream) {
-    return on_init_failed<CUresult >(300);
+    return on_init_failed<CUresult >(354);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_init(CUstream arg0) {
     load_library();
     return cuStreamSynchronize(arg0);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_error(CUstream) {
-    return on_init_failed<CUresult >(301);
+    return on_init_failed<CUresult >(355);
 }
 static CUresult _WRAPLIB_API_CALL cuEventRecord_init(CUevent arg0, CUstream arg1) {
     load_library();
     return cuEventRecord(arg0, arg1);
 }
 static CUresult _WRAPLIB_API_CALL cuEventRecord_error(CUevent, CUstream) {
-    return on_init_failed<CUresult >(302);
+    return on_init_failed<CUresult >(356);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
     load_library();
     return cuLaunchKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
 }
 static CUresult _WRAPLIB_API_CALL cuLaunchKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
-    return on_init_failed<CUresult >(303);
+    return on_init_failed<CUresult >(357);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(358);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     load_library();
     return cuGraphicsMapResources(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
-    return on_init_failed<CUresult >(304);
+    return on_init_failed<CUresult >(359);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     load_library();
     return cuGraphicsUnmapResources(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
-    return on_init_failed<CUresult >(305);
-}
-static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
-    load_library();
-    return cuMemPrefetchAsync(arg0, arg1, arg2, arg3);
-}
-static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_error(CUdeviceptr, size_t, CUdevice, CUstream) {
-    return on_init_failed<CUresult >(306);
+    return on_init_failed<CUresult >(360);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     load_library();
     return cuStreamWriteValue32(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
-    return on_init_failed<CUresult >(307);
+    return on_init_failed<CUresult >(361);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     load_library();
     return cuStreamWaitValue32(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
-    return on_init_failed<CUresult >(308);
+    return on_init_failed<CUresult >(362);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(363);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(364);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
     load_library();
     return cuStreamBatchMemOp(arg0, arg1, arg2, arg3);
 }
 static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
-    return on_init_failed<CUresult >(309);
+    return on_init_failed<CUresult >(365);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(366);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(367);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(368);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(369);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_error(CUstream) {
+    return on_init_failed<CUresult >(370);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(371);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(372);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(373);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(374);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(375);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(376);
 }
 static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_init(const char *arg0, const char *arg1, CUoutput_mode arg2) {
     load_library();
     return cuProfilerInitialize(arg0, arg1, arg2);
 }
 static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_error(const char *, const char *, CUoutput_mode) {
-    return on_init_failed<CUresult >(310);
+    return on_init_failed<CUresult >(377);
 }
 static CUresult _WRAPLIB_API_CALL cuProfilerStart_init() {
     load_library();
     return cuProfilerStart();
 }
 static CUresult _WRAPLIB_API_CALL cuProfilerStart_error() {
-    return on_init_failed<CUresult >(311);
+    return on_init_failed<CUresult >(378);
 }
 static CUresult _WRAPLIB_API_CALL cuProfilerStop_init() {
     load_library();
     return cuProfilerStop();
 }
 static CUresult _WRAPLIB_API_CALL cuProfilerStop_error() {
-    return on_init_failed<CUresult >(312);
+    return on_init_failed<CUresult >(379);
 }
-static constexpr size_t NR_FUNC = 313;
+static constexpr size_t NR_FUNC = 380;
 static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuGetErrorName_init),
     (void*)(&cuInit_init),
@@ -2217,6 +2686,7 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuDeviceGet_init),
     (void*)(&cuDeviceGetCount_init),
     (void*)(&cuDeviceGetName_init),
+    (void*)(&cuDeviceGetUuid_init),
     (void*)(&cuDeviceTotalMem_v2_init),
     (void*)(&cuDeviceGetAttribute_init),
     (void*)(&cuDeviceGetProperties_init),
@@ -2334,8 +2804,14 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuStreamCreateWithPriority_init),
     (void*)(&cuStreamGetPriority_ptsz_init),
     (void*)(&cuStreamGetFlags_ptsz_init),
+    (void*)(&cuStreamGetCtx_ptsz_init),
     (void*)(&cuStreamWaitEvent_ptsz_init),
     (void*)(&cuStreamAddCallback_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_init),
+    (void*)(&cuThreadExchangeStreamCaptureMode_init),
+    (void*)(&cuStreamEndCapture_ptsz_init),
+    (void*)(&cuStreamIsCapturing_ptsz_init),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_init),
     (void*)(&cuStreamAttachMemAsync_ptsz_init),
     (void*)(&cuStreamQuery_ptsz_init),
     (void*)(&cuStreamSynchronize_ptsz_init),
@@ -2346,13 +2822,27 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuEventSynchronize_init),
     (void*)(&cuEventDestroy_v2_init),
     (void*)(&cuEventElapsedTime_init),
+    (void*)(&cuImportExternalMemory_init),
+    (void*)(&cuExternalMemoryGetMappedBuffer_init),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_init),
+    (void*)(&cuDestroyExternalMemory_init),
+    (void*)(&cuImportExternalSemaphore_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuDestroyExternalSemaphore_init),
     (void*)(&cuStreamWaitValue32_ptsz_init),
+    (void*)(&cuStreamWaitValue64_ptsz_init),
     (void*)(&cuStreamWriteValue32_ptsz_init),
+    (void*)(&cuStreamWriteValue64_ptsz_init),
     (void*)(&cuStreamBatchMemOp_ptsz_init),
     (void*)(&cuFuncGetAttribute_init),
+    (void*)(&cuFuncSetAttribute_init),
     (void*)(&cuFuncSetCacheConfig_init),
     (void*)(&cuFuncSetSharedMemConfig_init),
     (void*)(&cuLaunchKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_init),
+    (void*)(&cuLaunchHostFunc_ptsz_init),
     (void*)(&cuFuncSetBlockShape_init),
     (void*)(&cuFuncSetSharedSize_init),
     (void*)(&cuParamSetSize_init),
@@ -2363,6 +2853,38 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuLaunchGrid_init),
     (void*)(&cuLaunchGridAsync_init),
     (void*)(&cuParamSetTexRef_init),
+    (void*)(&cuGraphCreate_init),
+    (void*)(&cuGraphAddKernelNode_init),
+    (void*)(&cuGraphKernelNodeGetParams_init),
+    (void*)(&cuGraphKernelNodeSetParams_init),
+    (void*)(&cuGraphAddMemcpyNode_init),
+    (void*)(&cuGraphMemcpyNodeGetParams_init),
+    (void*)(&cuGraphMemcpyNodeSetParams_init),
+    (void*)(&cuGraphAddMemsetNode_init),
+    (void*)(&cuGraphMemsetNodeGetParams_init),
+    (void*)(&cuGraphMemsetNodeSetParams_init),
+    (void*)(&cuGraphAddHostNode_init),
+    (void*)(&cuGraphHostNodeGetParams_init),
+    (void*)(&cuGraphHostNodeSetParams_init),
+    (void*)(&cuGraphAddChildGraphNode_init),
+    (void*)(&cuGraphChildGraphNodeGetGraph_init),
+    (void*)(&cuGraphAddEmptyNode_init),
+    (void*)(&cuGraphClone_init),
+    (void*)(&cuGraphNodeFindInClone_init),
+    (void*)(&cuGraphNodeGetType_init),
+    (void*)(&cuGraphGetNodes_init),
+    (void*)(&cuGraphGetRootNodes_init),
+    (void*)(&cuGraphGetEdges_init),
+    (void*)(&cuGraphNodeGetDependencies_init),
+    (void*)(&cuGraphNodeGetDependentNodes_init),
+    (void*)(&cuGraphAddDependencies_init),
+    (void*)(&cuGraphRemoveDependencies_init),
+    (void*)(&cuGraphDestroyNode_init),
+    (void*)(&cuGraphInstantiate_init),
+    (void*)(&cuGraphExecKernelNodeSetParams_init),
+    (void*)(&cuGraphLaunch_ptsz_init),
+    (void*)(&cuGraphExecDestroy_init),
+    (void*)(&cuGraphDestroy_init),
     (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_init),
     (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init),
     (void*)(&cuOccupancyMaxPotentialBlockSize_init),
@@ -2405,9 +2927,9 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuSurfObjectDestroy_init),
     (void*)(&cuSurfObjectGetResourceDesc_init),
     (void*)(&cuDeviceCanAccessPeer_init),
-    (void*)(&cuDeviceGetP2PAttribute_init),
     (void*)(&cuCtxEnablePeerAccess_init),
     (void*)(&cuCtxDisablePeerAccess_init),
+    (void*)(&cuDeviceGetP2PAttribute_init),
     (void*)(&cuGraphicsUnregisterResource_init),
     (void*)(&cuGraphicsSubResourceGetMappedArray_init),
     (void*)(&cuGraphicsResourceGetMappedMipmappedArray_init),
@@ -2507,6 +3029,7 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuMemsetD2D32Async_init),
     (void*)(&cuStreamGetPriority_init),
     (void*)(&cuStreamGetFlags_init),
+    (void*)(&cuStreamGetCtx_init),
     (void*)(&cuStreamWaitEvent_init),
     (void*)(&cuStreamAddCallback_init),
     (void*)(&cuStreamAttachMemAsync_init),
@@ -2514,12 +3037,25 @@ static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
     (void*)(&cuStreamSynchronize_init),
     (void*)(&cuEventRecord_init),
     (void*)(&cuLaunchKernel_init),
+    (void*)(&cuLaunchHostFunc_init),
     (void*)(&cuGraphicsMapResources_init),
     (void*)(&cuGraphicsUnmapResources_init),
-    (void*)(&cuMemPrefetchAsync_init),
     (void*)(&cuStreamWriteValue32_init),
     (void*)(&cuStreamWaitValue32_init),
+    (void*)(&cuStreamWriteValue64_init),
+    (void*)(&cuStreamWaitValue64_init),
     (void*)(&cuStreamBatchMemOp_init),
+    (void*)(&cuMemPrefetchAsync_init),
+    (void*)(&cuLaunchCooperativeKernel_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_init),
+    (void*)(&cuStreamBeginCapture_init),
+    (void*)(&cuStreamBeginCapture_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_init),
+    (void*)(&cuStreamEndCapture_init),
+    (void*)(&cuStreamIsCapturing_init),
+    (void*)(&cuStreamGetCaptureInfo_init),
+    (void*)(&cuGraphLaunch_init),
     (void*)(&cuProfilerInitialize_init),
     (void*)(&cuProfilerStart_init),
     (void*)(&cuProfilerStop_init)};
@@ -2530,6 +3066,7 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuDeviceGet_error),
     (void*)(&cuDeviceGetCount_error),
     (void*)(&cuDeviceGetName_error),
+    (void*)(&cuDeviceGetUuid_error),
     (void*)(&cuDeviceTotalMem_v2_error),
     (void*)(&cuDeviceGetAttribute_error),
     (void*)(&cuDeviceGetProperties_error),
@@ -2647,8 +3184,14 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuStreamCreateWithPriority_error),
     (void*)(&cuStreamGetPriority_ptsz_error),
     (void*)(&cuStreamGetFlags_ptsz_error),
+    (void*)(&cuStreamGetCtx_ptsz_error),
     (void*)(&cuStreamWaitEvent_ptsz_error),
     (void*)(&cuStreamAddCallback_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_error),
+    (void*)(&cuThreadExchangeStreamCaptureMode_error),
+    (void*)(&cuStreamEndCapture_ptsz_error),
+    (void*)(&cuStreamIsCapturing_ptsz_error),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_error),
     (void*)(&cuStreamAttachMemAsync_ptsz_error),
     (void*)(&cuStreamQuery_ptsz_error),
     (void*)(&cuStreamSynchronize_ptsz_error),
@@ -2659,13 +3202,27 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuEventSynchronize_error),
     (void*)(&cuEventDestroy_v2_error),
     (void*)(&cuEventElapsedTime_error),
+    (void*)(&cuImportExternalMemory_error),
+    (void*)(&cuExternalMemoryGetMappedBuffer_error),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_error),
+    (void*)(&cuDestroyExternalMemory_error),
+    (void*)(&cuImportExternalSemaphore_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuDestroyExternalSemaphore_error),
     (void*)(&cuStreamWaitValue32_ptsz_error),
+    (void*)(&cuStreamWaitValue64_ptsz_error),
     (void*)(&cuStreamWriteValue32_ptsz_error),
+    (void*)(&cuStreamWriteValue64_ptsz_error),
     (void*)(&cuStreamBatchMemOp_ptsz_error),
     (void*)(&cuFuncGetAttribute_error),
+    (void*)(&cuFuncSetAttribute_error),
     (void*)(&cuFuncSetCacheConfig_error),
     (void*)(&cuFuncSetSharedMemConfig_error),
     (void*)(&cuLaunchKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_error),
+    (void*)(&cuLaunchHostFunc_ptsz_error),
     (void*)(&cuFuncSetBlockShape_error),
     (void*)(&cuFuncSetSharedSize_error),
     (void*)(&cuParamSetSize_error),
@@ -2676,6 +3233,38 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuLaunchGrid_error),
     (void*)(&cuLaunchGridAsync_error),
     (void*)(&cuParamSetTexRef_error),
+    (void*)(&cuGraphCreate_error),
+    (void*)(&cuGraphAddKernelNode_error),
+    (void*)(&cuGraphKernelNodeGetParams_error),
+    (void*)(&cuGraphKernelNodeSetParams_error),
+    (void*)(&cuGraphAddMemcpyNode_error),
+    (void*)(&cuGraphMemcpyNodeGetParams_error),
+    (void*)(&cuGraphMemcpyNodeSetParams_error),
+    (void*)(&cuGraphAddMemsetNode_error),
+    (void*)(&cuGraphMemsetNodeGetParams_error),
+    (void*)(&cuGraphMemsetNodeSetParams_error),
+    (void*)(&cuGraphAddHostNode_error),
+    (void*)(&cuGraphHostNodeGetParams_error),
+    (void*)(&cuGraphHostNodeSetParams_error),
+    (void*)(&cuGraphAddChildGraphNode_error),
+    (void*)(&cuGraphChildGraphNodeGetGraph_error),
+    (void*)(&cuGraphAddEmptyNode_error),
+    (void*)(&cuGraphClone_error),
+    (void*)(&cuGraphNodeFindInClone_error),
+    (void*)(&cuGraphNodeGetType_error),
+    (void*)(&cuGraphGetNodes_error),
+    (void*)(&cuGraphGetRootNodes_error),
+    (void*)(&cuGraphGetEdges_error),
+    (void*)(&cuGraphNodeGetDependencies_error),
+    (void*)(&cuGraphNodeGetDependentNodes_error),
+    (void*)(&cuGraphAddDependencies_error),
+    (void*)(&cuGraphRemoveDependencies_error),
+    (void*)(&cuGraphDestroyNode_error),
+    (void*)(&cuGraphInstantiate_error),
+    (void*)(&cuGraphExecKernelNodeSetParams_error),
+    (void*)(&cuGraphLaunch_ptsz_error),
+    (void*)(&cuGraphExecDestroy_error),
+    (void*)(&cuGraphDestroy_error),
     (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_error),
     (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error),
     (void*)(&cuOccupancyMaxPotentialBlockSize_error),
@@ -2718,9 +3307,9 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuSurfObjectDestroy_error),
     (void*)(&cuSurfObjectGetResourceDesc_error),
     (void*)(&cuDeviceCanAccessPeer_error),
-    (void*)(&cuDeviceGetP2PAttribute_error),
     (void*)(&cuCtxEnablePeerAccess_error),
     (void*)(&cuCtxDisablePeerAccess_error),
+    (void*)(&cuDeviceGetP2PAttribute_error),
     (void*)(&cuGraphicsUnregisterResource_error),
     (void*)(&cuGraphicsSubResourceGetMappedArray_error),
     (void*)(&cuGraphicsResourceGetMappedMipmappedArray_error),
@@ -2820,6 +3409,7 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuMemsetD2D32Async_error),
     (void*)(&cuStreamGetPriority_error),
     (void*)(&cuStreamGetFlags_error),
+    (void*)(&cuStreamGetCtx_error),
     (void*)(&cuStreamWaitEvent_error),
     (void*)(&cuStreamAddCallback_error),
     (void*)(&cuStreamAttachMemAsync_error),
@@ -2827,12 +3417,25 @@ static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
     (void*)(&cuStreamSynchronize_error),
     (void*)(&cuEventRecord_error),
     (void*)(&cuLaunchKernel_error),
+    (void*)(&cuLaunchHostFunc_error),
     (void*)(&cuGraphicsMapResources_error),
     (void*)(&cuGraphicsUnmapResources_error),
-    (void*)(&cuMemPrefetchAsync_error),
     (void*)(&cuStreamWriteValue32_error),
     (void*)(&cuStreamWaitValue32_error),
+    (void*)(&cuStreamWriteValue64_error),
+    (void*)(&cuStreamWaitValue64_error),
     (void*)(&cuStreamBatchMemOp_error),
+    (void*)(&cuMemPrefetchAsync_error),
+    (void*)(&cuLaunchCooperativeKernel_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_error),
+    (void*)(&cuStreamBeginCapture_error),
+    (void*)(&cuStreamBeginCapture_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_error),
+    (void*)(&cuStreamEndCapture_error),
+    (void*)(&cuStreamIsCapturing_error),
+    (void*)(&cuStreamGetCaptureInfo_error),
+    (void*)(&cuGraphLaunch_error),
     (void*)(&cuProfilerInitialize_error),
     (void*)(&cuProfilerStart_error),
     (void*)(&cuProfilerStop_error)};
@@ -2843,6 +3446,7 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuDeviceGet",
     "cuDeviceGetCount",
     "cuDeviceGetName",
+    "cuDeviceGetUuid",
     "cuDeviceTotalMem_v2",
     "cuDeviceGetAttribute",
     "cuDeviceGetProperties",
@@ -2960,8 +3564,14 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuStreamCreateWithPriority",
     "cuStreamGetPriority_ptsz",
     "cuStreamGetFlags_ptsz",
+    "cuStreamGetCtx_ptsz",
     "cuStreamWaitEvent_ptsz",
     "cuStreamAddCallback_ptsz",
+    "cuStreamBeginCapture_v2_ptsz",
+    "cuThreadExchangeStreamCaptureMode",
+    "cuStreamEndCapture_ptsz",
+    "cuStreamIsCapturing_ptsz",
+    "cuStreamGetCaptureInfo_ptsz",
     "cuStreamAttachMemAsync_ptsz",
     "cuStreamQuery_ptsz",
     "cuStreamSynchronize_ptsz",
@@ -2972,13 +3582,27 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuEventSynchronize",
     "cuEventDestroy_v2",
     "cuEventElapsedTime",
+    "cuImportExternalMemory",
+    "cuExternalMemoryGetMappedBuffer",
+    "cuExternalMemoryGetMappedMipmappedArray",
+    "cuDestroyExternalMemory",
+    "cuImportExternalSemaphore",
+    "cuSignalExternalSemaphoresAsync_ptsz",
+    "cuWaitExternalSemaphoresAsync_ptsz",
+    "cuDestroyExternalSemaphore",
     "cuStreamWaitValue32_ptsz",
+    "cuStreamWaitValue64_ptsz",
     "cuStreamWriteValue32_ptsz",
+    "cuStreamWriteValue64_ptsz",
     "cuStreamBatchMemOp_ptsz",
     "cuFuncGetAttribute",
+    "cuFuncSetAttribute",
     "cuFuncSetCacheConfig",
     "cuFuncSetSharedMemConfig",
     "cuLaunchKernel_ptsz",
+    "cuLaunchCooperativeKernel_ptsz",
+    "cuLaunchCooperativeKernelMultiDevice",
+    "cuLaunchHostFunc_ptsz",
     "cuFuncSetBlockShape",
     "cuFuncSetSharedSize",
     "cuParamSetSize",
@@ -2989,6 +3613,38 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuLaunchGrid",
     "cuLaunchGridAsync",
     "cuParamSetTexRef",
+    "cuGraphCreate",
+    "cuGraphAddKernelNode",
+    "cuGraphKernelNodeGetParams",
+    "cuGraphKernelNodeSetParams",
+    "cuGraphAddMemcpyNode",
+    "cuGraphMemcpyNodeGetParams",
+    "cuGraphMemcpyNodeSetParams",
+    "cuGraphAddMemsetNode",
+    "cuGraphMemsetNodeGetParams",
+    "cuGraphMemsetNodeSetParams",
+    "cuGraphAddHostNode",
+    "cuGraphHostNodeGetParams",
+    "cuGraphHostNodeSetParams",
+    "cuGraphAddChildGraphNode",
+    "cuGraphChildGraphNodeGetGraph",
+    "cuGraphAddEmptyNode",
+    "cuGraphClone",
+    "cuGraphNodeFindInClone",
+    "cuGraphNodeGetType",
+    "cuGraphGetNodes",
+    "cuGraphGetRootNodes",
+    "cuGraphGetEdges",
+    "cuGraphNodeGetDependencies",
+    "cuGraphNodeGetDependentNodes",
+    "cuGraphAddDependencies",
+    "cuGraphRemoveDependencies",
+    "cuGraphDestroyNode",
+    "cuGraphInstantiate",
+    "cuGraphExecKernelNodeSetParams",
+    "cuGraphLaunch_ptsz",
+    "cuGraphExecDestroy",
+    "cuGraphDestroy",
     "cuOccupancyMaxActiveBlocksPerMultiprocessor",
     "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags",
     "cuOccupancyMaxPotentialBlockSize",
@@ -3031,9 +3687,9 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuSurfObjectDestroy",
     "cuSurfObjectGetResourceDesc",
     "cuDeviceCanAccessPeer",
-    "cuDeviceGetP2PAttribute",
     "cuCtxEnablePeerAccess",
     "cuCtxDisablePeerAccess",
+    "cuDeviceGetP2PAttribute",
     "cuGraphicsUnregisterResource",
     "cuGraphicsSubResourceGetMappedArray",
     "cuGraphicsResourceGetMappedMipmappedArray",
@@ -3133,6 +3789,7 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuMemsetD2D32Async",
     "cuStreamGetPriority",
     "cuStreamGetFlags",
+    "cuStreamGetCtx",
     "cuStreamWaitEvent",
     "cuStreamAddCallback",
     "cuStreamAttachMemAsync",
@@ -3140,12 +3797,25 @@ static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
     "cuStreamSynchronize",
     "cuEventRecord",
     "cuLaunchKernel",
+    "cuLaunchHostFunc",
     "cuGraphicsMapResources",
     "cuGraphicsUnmapResources",
-    "cuMemPrefetchAsync",
     "cuStreamWriteValue32",
     "cuStreamWaitValue32",
+    "cuStreamWriteValue64",
+    "cuStreamWaitValue64",
     "cuStreamBatchMemOp",
+    "cuMemPrefetchAsync",
+    "cuLaunchCooperativeKernel",
+    "cuSignalExternalSemaphoresAsync",
+    "cuWaitExternalSemaphoresAsync",
+    "cuStreamBeginCapture",
+    "cuStreamBeginCapture_ptsz",
+    "cuStreamBeginCapture_v2",
+    "cuStreamEndCapture",
+    "cuStreamIsCapturing",
+    "cuStreamGetCaptureInfo",
+    "cuGraphLaunch",
     "cuProfilerInitialize",
     "cuProfilerStart",
     "cuProfilerStop"};
@@ -3216,1839 +3886,2241 @@ CUresult _WRAPLIB_API_CALL cuDeviceGetName(char *arg0, int arg1, CUdevice arg2)
     f_ptr_t f = (f_ptr_t)(g_func_table[6]);
     return f(arg0, arg1, arg2);
 }
+CUresult _WRAPLIB_API_CALL cuDeviceGetUuid(CUuuid *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUuuid *, CUdevice);
+    ON_ENTRY(cuDeviceGetUuid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
+    return f(arg0, arg1);
+}
 CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2(size_t *arg0, CUdevice arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUdevice);
     ON_ENTRY(cuDeviceTotalMem_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_attribute, CUdevice);
     ON_ENTRY(cuDeviceGetAttribute);
-    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceGetProperties(CUdevprop *arg0, CUdevice arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevprop *, CUdevice);
     ON_ENTRY(cuDeviceGetProperties);
-    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability(int *arg0, int *arg1, CUdevice arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUdevice);
     ON_ENTRY(cuDeviceComputeCapability);
-    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain(CUcontext *arg0, CUdevice arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, CUdevice);
     ON_ENTRY(cuDevicePrimaryCtxRetain);
-    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease(CUdevice arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
     ON_ENTRY(cuDevicePrimaryCtxRelease);
-    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags(CUdevice arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int);
     ON_ENTRY(cuDevicePrimaryCtxSetFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState(CUdevice arg0, unsigned int *arg1, int *arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int *, int *);
     ON_ENTRY(cuDevicePrimaryCtxGetState);
-    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[15]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset(CUdevice arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
     ON_ENTRY(cuDevicePrimaryCtxReset);
-    f_ptr_t f = (f_ptr_t)(g_func_table[15]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[16]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxCreate_v2(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
     ON_ENTRY(cuCtxCreate_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[16]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[17]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxDestroy_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[17]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[18]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxPushCurrent_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[18]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[19]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2(CUcontext *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
     ON_ENTRY(cuCtxPopCurrent_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[19]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxSetCurrent(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxSetCurrent);
-    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[21]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetCurrent(CUcontext *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
     ON_ENTRY(cuCtxGetCurrent);
-    f_ptr_t f = (f_ptr_t)(g_func_table[21]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[22]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetDevice(CUdevice *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *);
     ON_ENTRY(cuCtxGetDevice);
-    f_ptr_t f = (f_ptr_t)(g_func_table[22]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[23]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetFlags(unsigned int *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *);
     ON_ENTRY(cuCtxGetFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[23]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[24]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxSynchronize() {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
     ON_ENTRY(cuCtxSynchronize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[24]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[25]);
     return f();
 }
 CUresult _WRAPLIB_API_CALL cuCtxSetLimit(CUlimit arg0, size_t arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlimit, size_t);
     ON_ENTRY(cuCtxSetLimit);
-    f_ptr_t f = (f_ptr_t)(g_func_table[25]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[26]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetLimit(size_t *arg0, CUlimit arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUlimit);
     ON_ENTRY(cuCtxGetLimit);
-    f_ptr_t f = (f_ptr_t)(g_func_table[26]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[27]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig(CUfunc_cache *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache *);
     ON_ENTRY(cuCtxGetCacheConfig);
-    f_ptr_t f = (f_ptr_t)(g_func_table[27]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[28]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig(CUfunc_cache arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache);
     ON_ENTRY(cuCtxSetCacheConfig);
-    f_ptr_t f = (f_ptr_t)(g_func_table[28]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[29]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig(CUsharedconfig *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig *);
     ON_ENTRY(cuCtxGetSharedMemConfig);
-    f_ptr_t f = (f_ptr_t)(g_func_table[29]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[30]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig(CUsharedconfig arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig);
     ON_ENTRY(cuCtxSetSharedMemConfig);
-    f_ptr_t f = (f_ptr_t)(g_func_table[30]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[31]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion(CUcontext arg0, unsigned int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int *);
     ON_ENTRY(cuCtxGetApiVersion);
-    f_ptr_t f = (f_ptr_t)(g_func_table[31]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[32]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange(int *arg0, int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *);
     ON_ENTRY(cuCtxGetStreamPriorityRange);
-    f_ptr_t f = (f_ptr_t)(g_func_table[32]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[33]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxAttach(CUcontext *arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int);
     ON_ENTRY(cuCtxAttach);
-    f_ptr_t f = (f_ptr_t)(g_func_table[33]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[34]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxDetach(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxDetach);
-    f_ptr_t f = (f_ptr_t)(g_func_table[34]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[35]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuModuleLoad(CUmodule *arg0, const char *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const char *);
     ON_ENTRY(cuModuleLoad);
-    f_ptr_t f = (f_ptr_t)(g_func_table[35]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[36]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuModuleLoadData(CUmodule *arg0, const void *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
     ON_ENTRY(cuModuleLoadData);
-    f_ptr_t f = (f_ptr_t)(g_func_table[36]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[37]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *, unsigned int, CUjit_option *, void **);
     ON_ENTRY(cuModuleLoadDataEx);
-    f_ptr_t f = (f_ptr_t)(g_func_table[37]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[38]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary(CUmodule *arg0, const void *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
     ON_ENTRY(cuModuleLoadFatBinary);
-    f_ptr_t f = (f_ptr_t)(g_func_table[38]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[39]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuModuleUnload(CUmodule arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule);
     ON_ENTRY(cuModuleUnload);
-    f_ptr_t f = (f_ptr_t)(g_func_table[39]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[40]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuModuleGetFunction(CUfunction *arg0, CUmodule arg1, const char *arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction *, CUmodule, const char *);
     ON_ENTRY(cuModuleGetFunction);
-    f_ptr_t f = (f_ptr_t)(g_func_table[40]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[41]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUmodule, const char *);
     ON_ENTRY(cuModuleGetGlobal_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[41]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[42]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuModuleGetTexRef(CUtexref *arg0, CUmodule arg1, const char *arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *, CUmodule, const char *);
     ON_ENTRY(cuModuleGetTexRef);
-    f_ptr_t f = (f_ptr_t)(g_func_table[42]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[43]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref *, CUmodule, const char *);
     ON_ENTRY(cuModuleGetSurfRef);
-    f_ptr_t f = (f_ptr_t)(g_func_table[43]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[44]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuLinkCreate_v2(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
     ON_ENTRY(cuLinkCreate_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[44]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[45]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuLinkAddData_v2(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
     ON_ENTRY(cuLinkAddData_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[45]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[46]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
 CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
     ON_ENTRY(cuLinkAddFile_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[46]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[47]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuLinkComplete(CUlinkState arg0, void **arg1, size_t *arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, void **, size_t *);
     ON_ENTRY(cuLinkComplete);
-    f_ptr_t f = (f_ptr_t)(g_func_table[47]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[48]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuLinkDestroy(CUlinkState arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState);
     ON_ENTRY(cuLinkDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[48]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[49]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2(size_t *arg0, size_t *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, size_t *);
     ON_ENTRY(cuMemGetInfo_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[49]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[50]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemAlloc_v2(CUdeviceptr *arg0, size_t arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t);
     ON_ENTRY(cuMemAlloc_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[50]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[51]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, size_t, size_t, unsigned int);
     ON_ENTRY(cuMemAllocPitch_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[51]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[52]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemFree_v2(CUdeviceptr arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
     ON_ENTRY(cuMemFree_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[52]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[53]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUdeviceptr);
     ON_ENTRY(cuMemGetAddressRange_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[53]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[54]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2(void **arg0, size_t arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t);
     ON_ENTRY(cuMemAllocHost_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[54]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[55]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemFreeHost(void *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
     ON_ENTRY(cuMemFreeHost);
-    f_ptr_t f = (f_ptr_t)(g_func_table[55]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[56]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostAlloc(void **arg0, size_t arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t, unsigned int);
     ON_ENTRY(cuMemHostAlloc);
-    f_ptr_t f = (f_ptr_t)(g_func_table[56]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[57]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, void *, unsigned int);
     ON_ENTRY(cuMemHostGetDevicePointer_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[57]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[58]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostGetFlags(unsigned int *arg0, void *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, void *);
     ON_ENTRY(cuMemHostGetFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[58]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[59]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemAllocManaged(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, unsigned int);
     ON_ENTRY(cuMemAllocManaged);
-    f_ptr_t f = (f_ptr_t)(g_func_table[59]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[60]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId(CUdevice *arg0, const char *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, const char *);
     ON_ENTRY(cuDeviceGetByPCIBusId);
-    f_ptr_t f = (f_ptr_t)(g_func_table[60]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[61]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId(char *arg0, int arg1, CUdevice arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
     ON_ENTRY(cuDeviceGetPCIBusId);
-    f_ptr_t f = (f_ptr_t)(g_func_table[61]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[62]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle(CUipcEventHandle *arg0, CUevent arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcEventHandle *, CUevent);
     ON_ENTRY(cuIpcGetEventHandle);
-    f_ptr_t f = (f_ptr_t)(g_func_table[62]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[63]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle(CUevent *arg0, CUipcEventHandle arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, CUipcEventHandle);
     ON_ENTRY(cuIpcOpenEventHandle);
-    f_ptr_t f = (f_ptr_t)(g_func_table[63]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[64]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle(CUipcMemHandle *arg0, CUdeviceptr arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcMemHandle *, CUdeviceptr);
     ON_ENTRY(cuIpcGetMemHandle);
-    f_ptr_t f = (f_ptr_t)(g_func_table[64]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[65]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUipcMemHandle, unsigned int);
     ON_ENTRY(cuIpcOpenMemHandle);
-    f_ptr_t f = (f_ptr_t)(g_func_table[65]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[66]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle(CUdeviceptr arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
     ON_ENTRY(cuIpcCloseMemHandle);
-    f_ptr_t f = (f_ptr_t)(g_func_table[66]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[67]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2(void *arg0, size_t arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
     ON_ENTRY(cuMemHostRegister_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[67]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[68]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostUnregister(void *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
     ON_ENTRY(cuMemHostUnregister);
-    f_ptr_t f = (f_ptr_t)(g_func_table[68]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[69]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpy_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[69]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[70]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
     ON_ENTRY(cuMemcpyPeer_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[70]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[71]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds(CUdeviceptr arg0, const void *arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
     ON_ENTRY(cuMemcpyHtoD_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[71]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[72]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds(void *arg0, CUdeviceptr arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpyDtoH_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[72]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[73]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpyDtoD_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[73]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[74]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpyDtoA_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[74]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[75]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
     ON_ENTRY(cuMemcpyAtoD_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[75]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[76]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
     ON_ENTRY(cuMemcpyHtoA_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[76]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[77]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
     ON_ENTRY(cuMemcpyAtoH_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[77]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[78]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
     ON_ENTRY(cuMemcpyAtoA_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[78]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[79]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds(const CUDA_MEMCPY2D *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
     ON_ENTRY(cuMemcpy2D_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[79]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[80]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds(const CUDA_MEMCPY2D *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
     ON_ENTRY(cuMemcpy2DUnaligned_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[80]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[81]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds(const CUDA_MEMCPY3D *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
     ON_ENTRY(cuMemcpy3D_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[81]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[82]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds(const CUDA_MEMCPY3D_PEER *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
     ON_ENTRY(cuMemcpy3DPeer_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[82]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[83]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
     ON_ENTRY(cuMemcpyAsync_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[83]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[84]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
     ON_ENTRY(cuMemcpyPeerAsync_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[84]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[85]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
     ON_ENTRY(cuMemcpyHtoDAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[85]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[86]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
     ON_ENTRY(cuMemcpyDtoHAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[86]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[87]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
     ON_ENTRY(cuMemcpyDtoDAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[87]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[88]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
     ON_ENTRY(cuMemcpyHtoAAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[88]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[89]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
     ON_ENTRY(cuMemcpyAtoHAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[89]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[90]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
     ON_ENTRY(cuMemcpy2DAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[90]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[91]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
     ON_ENTRY(cuMemcpy3DAsync_v2_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[91]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[92]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
     ON_ENTRY(cuMemcpy3DPeerAsync_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[92]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[93]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
     ON_ENTRY(cuMemsetD8_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[93]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[94]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
     ON_ENTRY(cuMemsetD16_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[94]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[95]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
     ON_ENTRY(cuMemsetD32_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[95]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[96]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
     ON_ENTRY(cuMemsetD2D8_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[96]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[97]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
     ON_ENTRY(cuMemsetD2D16_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[97]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[98]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
     ON_ENTRY(cuMemsetD2D32_v2_ptds);
-    f_ptr_t f = (f_ptr_t)(g_func_table[98]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[99]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
     ON_ENTRY(cuMemsetD8Async_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[99]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[100]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
     ON_ENTRY(cuMemsetD16Async_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[100]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[101]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
     ON_ENTRY(cuMemsetD32Async_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[101]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[102]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
     ON_ENTRY(cuMemsetD2D8Async_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[102]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[103]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
     ON_ENTRY(cuMemsetD2D16Async_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[103]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[104]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
     ON_ENTRY(cuMemsetD2D32Async_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[104]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[105]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuArrayCreate_v2(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR *);
     ON_ENTRY(cuArrayCreate_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[105]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[106]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR *, CUarray);
     ON_ENTRY(cuArrayGetDescriptor_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[106]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[107]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuArrayDestroy(CUarray arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray);
     ON_ENTRY(cuArrayDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[107]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[108]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *);
     ON_ENTRY(cuArray3DCreate_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[108]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[109]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR *, CUarray);
     ON_ENTRY(cuArray3DGetDescriptor_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[109]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[110]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int);
     ON_ENTRY(cuMipmappedArrayCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[110]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[111]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUmipmappedArray, unsigned int);
     ON_ENTRY(cuMipmappedArrayGetLevel);
-    f_ptr_t f = (f_ptr_t)(g_func_table[111]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[112]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy(CUmipmappedArray arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray);
     ON_ENTRY(cuMipmappedArrayDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[112]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[113]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuPointerGetAttribute(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUpointer_attribute, CUdeviceptr);
     ON_ENTRY(cuPointerGetAttribute);
-    f_ptr_t f = (f_ptr_t)(g_func_table[113]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[114]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
     ON_ENTRY(cuMemPrefetchAsync_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[114]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[115]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemAdvise(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUmem_advise, CUdevice);
     ON_ENTRY(cuMemAdvise);
-    f_ptr_t f = (f_ptr_t)(g_func_table[115]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[116]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t);
     ON_ENTRY(cuMemRangeGetAttribute);
-    f_ptr_t f = (f_ptr_t)(g_func_table[116]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[117]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t);
     ON_ENTRY(cuMemRangeGetAttributes);
-    f_ptr_t f = (f_ptr_t)(g_func_table[117]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[118]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuPointerSetAttribute(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void *, CUpointer_attribute, CUdeviceptr);
     ON_ENTRY(cuPointerSetAttribute);
-    f_ptr_t f = (f_ptr_t)(g_func_table[118]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[119]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuPointerGetAttributes(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUpointer_attribute *, void **, CUdeviceptr);
     ON_ENTRY(cuPointerGetAttributes);
-    f_ptr_t f = (f_ptr_t)(g_func_table[119]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[120]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamCreate(CUstream *arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int);
     ON_ENTRY(cuStreamCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[120]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[121]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority(CUstream *arg0, unsigned int arg1, int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int, int);
     ON_ENTRY(cuStreamCreateWithPriority);
-    f_ptr_t f = (f_ptr_t)(g_func_table[121]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[122]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz(CUstream arg0, int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
     ON_ENTRY(cuStreamGetPriority_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[122]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[123]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz(CUstream arg0, unsigned int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
     ON_ENTRY(cuStreamGetFlags_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[123]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[124]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[125]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz(CUstream arg0, CUevent arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
     ON_ENTRY(cuStreamWaitEvent_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[124]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[126]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
     ON_ENTRY(cuStreamAddCallback_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[125]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[127]);
     return f(arg0, arg1, arg2, arg3);
 }
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[128]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstreamCaptureMode *);
+    ON_ENTRY(cuThreadExchangeStreamCaptureMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[129]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[130]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[131]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[132]);
+    return f(arg0, arg1, arg2);
+}
 CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
     ON_ENTRY(cuStreamAttachMemAsync_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[126]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[133]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz(CUstream arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
     ON_ENTRY(cuStreamQuery_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[127]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[134]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz(CUstream arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
     ON_ENTRY(cuStreamSynchronize_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[128]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[135]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2(CUstream arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
     ON_ENTRY(cuStreamDestroy_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[129]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[136]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuEventCreate(CUevent *arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, unsigned int);
     ON_ENTRY(cuEventCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[130]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[137]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz(CUevent arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
     ON_ENTRY(cuEventRecord_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[131]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[138]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuEventQuery(CUevent arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
     ON_ENTRY(cuEventQuery);
-    f_ptr_t f = (f_ptr_t)(g_func_table[132]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[139]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuEventSynchronize(CUevent arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
     ON_ENTRY(cuEventSynchronize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[133]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[140]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuEventDestroy_v2(CUevent arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
     ON_ENTRY(cuEventDestroy_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[134]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[141]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuEventElapsedTime(float *arg0, CUevent arg1, CUevent arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUevent, CUevent);
     ON_ENTRY(cuEventElapsedTime);
-    f_ptr_t f = (f_ptr_t)(g_func_table[135]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[142]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalMemory(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[143]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedBuffer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[144]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[145]);
     return f(arg0, arg1, arg2);
 }
+CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory(CUexternalMemory arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory);
+    ON_ENTRY(cuDestroyExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[146]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[147]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[148]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[149]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore(CUexternalSemaphore arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore);
+    ON_ENTRY(cuDestroyExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[150]);
+    return f(arg0);
+}
 CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
     ON_ENTRY(cuStreamWaitValue32_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[136]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[151]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[152]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
     ON_ENTRY(cuStreamWriteValue32_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[137]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[153]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[154]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
     ON_ENTRY(cuStreamBatchMemOp_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[138]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[155]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuFuncGetAttribute(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction_attribute, CUfunction);
     ON_ENTRY(cuFuncGetAttribute);
-    f_ptr_t f = (f_ptr_t)(g_func_table[139]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[156]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetAttribute(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunction_attribute, int);
+    ON_ENTRY(cuFuncSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[157]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig(CUfunction arg0, CUfunc_cache arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunc_cache);
     ON_ENTRY(cuFuncSetCacheConfig);
-    f_ptr_t f = (f_ptr_t)(g_func_table[140]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[158]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig(CUfunction arg0, CUsharedconfig arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUsharedconfig);
     ON_ENTRY(cuFuncSetSharedMemConfig);
-    f_ptr_t f = (f_ptr_t)(g_func_table[141]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[159]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
     ON_ENTRY(cuLaunchKernel_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[142]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[160]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
 }
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[161]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int);
+    ON_ENTRY(cuLaunchCooperativeKernelMultiDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[162]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[163]);
+    return f(arg0, arg1, arg2);
+}
 CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape(CUfunction arg0, int arg1, int arg2, int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, int);
     ON_ENTRY(cuFuncSetBlockShape);
-    f_ptr_t f = (f_ptr_t)(g_func_table[143]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[164]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize(CUfunction arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
     ON_ENTRY(cuFuncSetSharedSize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[144]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[165]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuParamSetSize(CUfunction arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
     ON_ENTRY(cuParamSetSize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[145]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[166]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuParamSeti(CUfunction arg0, int arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, unsigned int);
     ON_ENTRY(cuParamSeti);
-    f_ptr_t f = (f_ptr_t)(g_func_table[146]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[167]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuParamSetf(CUfunction arg0, int arg1, float arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, float);
     ON_ENTRY(cuParamSetf);
-    f_ptr_t f = (f_ptr_t)(g_func_table[147]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[168]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuParamSetv(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, void *, unsigned int);
     ON_ENTRY(cuParamSetv);
-    f_ptr_t f = (f_ptr_t)(g_func_table[148]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[169]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuLaunch(CUfunction arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction);
     ON_ENTRY(cuLaunch);
-    f_ptr_t f = (f_ptr_t)(g_func_table[149]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[170]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuLaunchGrid(CUfunction arg0, int arg1, int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int);
     ON_ENTRY(cuLaunchGrid);
-    f_ptr_t f = (f_ptr_t)(g_func_table[150]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[171]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuLaunchGridAsync(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, CUstream);
     ON_ENTRY(cuLaunchGridAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[151]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[172]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuParamSetTexRef(CUfunction arg0, int arg1, CUtexref arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, CUtexref);
     ON_ENTRY(cuParamSetTexRef);
-    f_ptr_t f = (f_ptr_t)(g_func_table[152]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[173]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphCreate(CUgraph *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, unsigned int);
+    ON_ENTRY(cuGraphCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[174]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddKernelNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[175]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[176]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[177]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphAddMemcpyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[178]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[179]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[180]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphAddMemsetNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[181]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[182]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[183]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddHostNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddHostNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[184]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[185]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[186]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph);
+    ON_ENTRY(cuGraphAddChildGraphNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[187]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph(CUgraphNode arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraph *);
+    ON_ENTRY(cuGraphChildGraphNodeGetGraph);
+    f_ptr_t f = (f_ptr_t)(g_func_table[188]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddEmptyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[189]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphClone(CUgraph *arg0, CUgraph arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, CUgraph);
+    ON_ENTRY(cuGraphClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[190]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraphNode, CUgraph);
+    ON_ENTRY(cuGraphNodeFindInClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[191]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetType(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNodeType *);
+    ON_ENTRY(cuGraphNodeGetType);
+    f_ptr_t f = (f_ptr_t)(g_func_table[192]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[193]);
     return f(arg0, arg1, arg2);
 }
+CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetRootNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[194]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetEdges(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetEdges);
+    f_ptr_t f = (f_ptr_t)(g_func_table[195]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[196]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependentNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[197]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[198]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphRemoveDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[199]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroyNode(CUgraphNode arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode);
+    ON_ENTRY(cuGraphDestroyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[200]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphInstantiate(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t);
+    ON_ENTRY(cuGraphInstantiate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[201]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[202]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[203]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecDestroy(CUgraphExec arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec);
+    ON_ENTRY(cuGraphExecDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[204]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroy(CUgraph arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph);
+    ON_ENTRY(cuGraphDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[205]);
+    return f(arg0);
+}
 CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t);
     ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessor);
-    f_ptr_t f = (f_ptr_t)(g_func_table[153]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[206]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t, unsigned int);
     ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[154]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[207]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int);
     ON_ENTRY(cuOccupancyMaxPotentialBlockSize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[155]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[208]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int);
     ON_ENTRY(cuOccupancyMaxPotentialBlockSizeWithFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[156]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[209]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetArray(CUtexref arg0, CUarray arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray, unsigned int);
     ON_ENTRY(cuTexRefSetArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[157]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[210]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUmipmappedArray, unsigned int);
     ON_ENTRY(cuTexRefSetMipmappedArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[158]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[211]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUtexref, CUdeviceptr, size_t);
     ON_ENTRY(cuTexRefSetAddress_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[159]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[212]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
     ON_ENTRY(cuTexRefSetAddress2D_v3);
-    f_ptr_t f = (f_ptr_t)(g_func_table[160]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[213]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetFormat(CUtexref arg0, CUarray_format arg1, int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray_format, int);
     ON_ENTRY(cuTexRefSetFormat);
-    f_ptr_t f = (f_ptr_t)(g_func_table[161]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[214]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode(CUtexref arg0, int arg1, CUaddress_mode arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, int, CUaddress_mode);
     ON_ENTRY(cuTexRefSetAddressMode);
-    f_ptr_t f = (f_ptr_t)(g_func_table[162]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[215]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode(CUtexref arg0, CUfilter_mode arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
     ON_ENTRY(cuTexRefSetFilterMode);
-    f_ptr_t f = (f_ptr_t)(g_func_table[163]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[216]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode(CUtexref arg0, CUfilter_mode arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
     ON_ENTRY(cuTexRefSetMipmapFilterMode);
-    f_ptr_t f = (f_ptr_t)(g_func_table[164]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[217]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias(CUtexref arg0, float arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float);
     ON_ENTRY(cuTexRefSetMipmapLevelBias);
-    f_ptr_t f = (f_ptr_t)(g_func_table[165]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[218]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp(CUtexref arg0, float arg1, float arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float, float);
     ON_ENTRY(cuTexRefSetMipmapLevelClamp);
-    f_ptr_t f = (f_ptr_t)(g_func_table[166]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[219]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy(CUtexref arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
     ON_ENTRY(cuTexRefSetMaxAnisotropy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[167]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[220]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor(CUtexref arg0, float *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float *);
     ON_ENTRY(cuTexRefSetBorderColor);
-    f_ptr_t f = (f_ptr_t)(g_func_table[168]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[221]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetFlags(CUtexref arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
     ON_ENTRY(cuTexRefSetFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[169]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[222]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2(CUdeviceptr *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUtexref);
     ON_ENTRY(cuTexRefGetAddress_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[170]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[223]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetArray(CUarray *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUtexref);
     ON_ENTRY(cuTexRefGetArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[171]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[224]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray(CUmipmappedArray *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUtexref);
     ON_ENTRY(cuTexRefGetMipmappedArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[172]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[225]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUaddress_mode *, CUtexref, int);
     ON_ENTRY(cuTexRefGetAddressMode);
-    f_ptr_t f = (f_ptr_t)(g_func_table[173]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[226]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
     ON_ENTRY(cuTexRefGetFilterMode);
-    f_ptr_t f = (f_ptr_t)(g_func_table[174]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[227]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetFormat(CUarray_format *arg0, int *arg1, CUtexref arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray_format *, int *, CUtexref);
     ON_ENTRY(cuTexRefGetFormat);
-    f_ptr_t f = (f_ptr_t)(g_func_table[175]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[228]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
     ON_ENTRY(cuTexRefGetMipmapFilterMode);
-    f_ptr_t f = (f_ptr_t)(g_func_table[176]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[229]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias(float *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
     ON_ENTRY(cuTexRefGetMipmapLevelBias);
-    f_ptr_t f = (f_ptr_t)(g_func_table[177]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[230]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp(float *arg0, float *arg1, CUtexref arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, float *, CUtexref);
     ON_ENTRY(cuTexRefGetMipmapLevelClamp);
-    f_ptr_t f = (f_ptr_t)(g_func_table[178]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[231]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy(int *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUtexref);
     ON_ENTRY(cuTexRefGetMaxAnisotropy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[179]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[232]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor(float *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
     ON_ENTRY(cuTexRefGetBorderColor);
-    f_ptr_t f = (f_ptr_t)(g_func_table[180]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[233]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetFlags(unsigned int *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref);
     ON_ENTRY(cuTexRefGetFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[181]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[234]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefCreate(CUtexref *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *);
     ON_ENTRY(cuTexRefCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[182]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[235]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefDestroy(CUtexref arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref);
     ON_ENTRY(cuTexRefDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[183]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[236]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuSurfRefSetArray(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref, CUarray, unsigned int);
     ON_ENTRY(cuSurfRefSetArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[184]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[237]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuSurfRefGetArray(CUarray *arg0, CUsurfref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUsurfref);
     ON_ENTRY(cuSurfRefGetArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[185]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[238]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexObjectCreate(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *);
     ON_ENTRY(cuTexObjectCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[186]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[239]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuTexObjectDestroy(CUtexObject arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject);
     ON_ENTRY(cuTexObjectDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[187]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[240]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUtexObject);
     ON_ENTRY(cuTexObjectGetResourceDesc);
-    f_ptr_t f = (f_ptr_t)(g_func_table[188]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[241]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_TEXTURE_DESC *, CUtexObject);
     ON_ENTRY(cuTexObjectGetTextureDesc);
-    f_ptr_t f = (f_ptr_t)(g_func_table[189]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[242]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_VIEW_DESC *, CUtexObject);
     ON_ENTRY(cuTexObjectGetResourceViewDesc);
-    f_ptr_t f = (f_ptr_t)(g_func_table[190]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[243]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuSurfObjectCreate(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject *, const CUDA_RESOURCE_DESC *);
     ON_ENTRY(cuSurfObjectCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[191]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[244]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy(CUsurfObject arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject);
     ON_ENTRY(cuSurfObjectDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[192]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[245]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUsurfObject);
     ON_ENTRY(cuSurfObjectGetResourceDesc);
-    f_ptr_t f = (f_ptr_t)(g_func_table[193]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[246]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer(int *arg0, CUdevice arg1, CUdevice arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice, CUdevice);
     ON_ENTRY(cuDeviceCanAccessPeer);
-    f_ptr_t f = (f_ptr_t)(g_func_table[194]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[247]);
     return f(arg0, arg1, arg2);
 }
-CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
-    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_P2PAttribute, CUdevice, CUdevice);
-    ON_ENTRY(cuDeviceGetP2PAttribute);
-    f_ptr_t f = (f_ptr_t)(g_func_table[195]);
-    return f(arg0, arg1, arg2, arg3);
-}
 CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess(CUcontext arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int);
     ON_ENTRY(cuCtxEnablePeerAccess);
-    f_ptr_t f = (f_ptr_t)(g_func_table[196]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[248]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxDisablePeerAccess);
-    f_ptr_t f = (f_ptr_t)(g_func_table[197]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[249]);
     return f(arg0);
 }
+CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_P2PAttribute, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceGetP2PAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[250]);
+    return f(arg0, arg1, arg2, arg3);
+}
 CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource(CUgraphicsResource arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource);
     ON_ENTRY(cuGraphicsUnregisterResource);
-    f_ptr_t f = (f_ptr_t)(g_func_table[198]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[251]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUgraphicsResource, unsigned int, unsigned int);
     ON_ENTRY(cuGraphicsSubResourceGetMappedArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[199]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[252]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUgraphicsResource);
     ON_ENTRY(cuGraphicsResourceGetMappedMipmappedArray);
-    f_ptr_t f = (f_ptr_t)(g_func_table[200]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[253]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUgraphicsResource);
     ON_ENTRY(cuGraphicsResourceGetMappedPointer_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[201]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[254]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2(CUgraphicsResource arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
     ON_ENTRY(cuGraphicsResourceSetMapFlags_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[202]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[255]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
     ON_ENTRY(cuGraphicsMapResources_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[203]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[256]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
     ON_ENTRY(cuGraphicsUnmapResources_ptsz);
-    f_ptr_t f = (f_ptr_t)(g_func_table[204]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[257]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuGetExportTable(const void **arg0, const CUuuid *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void **, const CUuuid *);
     ON_ENTRY(cuGetExportTable);
-    f_ptr_t f = (f_ptr_t)(g_func_table[205]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[258]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostRegister(void *arg0, size_t arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
     ON_ENTRY(cuMemHostRegister);
-    f_ptr_t f = (f_ptr_t)(g_func_table[206]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[259]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags(CUgraphicsResource arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
     ON_ENTRY(cuGraphicsResourceSetMapFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[207]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[260]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuLinkCreate(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
     ON_ENTRY(cuLinkCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[208]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[261]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuLinkAddData(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
     ON_ENTRY(cuLinkAddData);
-    f_ptr_t f = (f_ptr_t)(g_func_table[209]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[262]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 }
 CUresult _WRAPLIB_API_CALL cuLinkAddFile(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
     ON_ENTRY(cuLinkAddFile);
-    f_ptr_t f = (f_ptr_t)(g_func_table[210]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[263]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
     ON_ENTRY(cuTexRefSetAddress2D_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[211]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[264]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuDeviceTotalMem(unsigned int *arg0, CUdevice arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUdevice);
     ON_ENTRY(cuDeviceTotalMem);
-    f_ptr_t f = (f_ptr_t)(g_func_table[212]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[265]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuCtxCreate(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
     ON_ENTRY(cuCtxCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[213]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[266]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuModuleGetGlobal(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *);
     ON_ENTRY(cuModuleGetGlobal);
-    f_ptr_t f = (f_ptr_t)(g_func_table[214]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[267]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemGetInfo(unsigned int *arg0, unsigned int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, unsigned int *);
     ON_ENTRY(cuMemGetInfo);
-    f_ptr_t f = (f_ptr_t)(g_func_table[215]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[268]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemAlloc(CUdeviceptr_v1 *arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int);
     ON_ENTRY(cuMemAlloc);
-    f_ptr_t f = (f_ptr_t)(g_func_table[216]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[269]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemAllocPitch(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int);
     ON_ENTRY(cuMemAllocPitch);
-    f_ptr_t f = (f_ptr_t)(g_func_table[217]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[270]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemFree(CUdeviceptr_v1 arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1);
     ON_ENTRY(cuMemFree);
-    f_ptr_t f = (f_ptr_t)(g_func_table[218]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[271]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemGetAddressRange(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1);
     ON_ENTRY(cuMemGetAddressRange);
-    f_ptr_t f = (f_ptr_t)(g_func_table[219]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[272]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemAllocHost(void **arg0, unsigned int arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, unsigned int);
     ON_ENTRY(cuMemAllocHost);
-    f_ptr_t f = (f_ptr_t)(g_func_table[220]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[273]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, void *, unsigned int);
     ON_ENTRY(cuMemHostGetDevicePointer);
-    f_ptr_t f = (f_ptr_t)(g_func_table[221]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[274]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoD(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int);
     ON_ENTRY(cuMemcpyHtoD);
-    f_ptr_t f = (f_ptr_t)(g_func_table[222]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[275]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoH(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int);
     ON_ENTRY(cuMemcpyDtoH);
-    f_ptr_t f = (f_ptr_t)(g_func_table[223]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[276]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoD(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int);
     ON_ENTRY(cuMemcpyDtoD);
-    f_ptr_t f = (f_ptr_t)(g_func_table[224]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[277]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoA(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUdeviceptr_v1, unsigned int);
     ON_ENTRY(cuMemcpyDtoA);
-    f_ptr_t f = (f_ptr_t)(g_func_table[225]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[278]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoD(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUarray, unsigned int, unsigned int);
     ON_ENTRY(cuMemcpyAtoD);
-    f_ptr_t f = (f_ptr_t)(g_func_table[226]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[279]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoA(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int);
     ON_ENTRY(cuMemcpyHtoA);
-    f_ptr_t f = (f_ptr_t)(g_func_table[227]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[280]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoH(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int);
     ON_ENTRY(cuMemcpyAtoH);
-    f_ptr_t f = (f_ptr_t)(g_func_table[228]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[281]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoA(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUarray, unsigned int, unsigned int);
     ON_ENTRY(cuMemcpyAtoA);
-    f_ptr_t f = (f_ptr_t)(g_func_table[229]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[282]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int, CUstream);
     ON_ENTRY(cuMemcpyHtoAAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[230]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[283]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int, CUstream);
     ON_ENTRY(cuMemcpyAtoHAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[231]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[284]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2D(const CUDA_MEMCPY2D_v1 *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
     ON_ENTRY(cuMemcpy2D);
-    f_ptr_t f = (f_ptr_t)(g_func_table[232]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[285]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned(const CUDA_MEMCPY2D_v1 *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
     ON_ENTRY(cuMemcpy2DUnaligned);
-    f_ptr_t f = (f_ptr_t)(g_func_table[233]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[286]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3D(const CUDA_MEMCPY3D_v1 *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *);
     ON_ENTRY(cuMemcpy3D);
-    f_ptr_t f = (f_ptr_t)(g_func_table[234]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[287]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int, CUstream);
     ON_ENTRY(cuMemcpyHtoDAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[235]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[288]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int, CUstream);
     ON_ENTRY(cuMemcpyDtoHAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[236]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[289]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream);
     ON_ENTRY(cuMemcpyDtoDAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[237]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[290]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *, CUstream);
     ON_ENTRY(cuMemcpy2DAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[238]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[291]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *, CUstream);
     ON_ENTRY(cuMemcpy3DAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[239]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[292]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD8(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned char, unsigned int);
     ON_ENTRY(cuMemsetD8);
-    f_ptr_t f = (f_ptr_t)(g_func_table[240]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[293]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD16(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned short, unsigned int);
     ON_ENTRY(cuMemsetD16);
-    f_ptr_t f = (f_ptr_t)(g_func_table[241]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[294]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int);
     ON_ENTRY(cuMemsetD32);
-    f_ptr_t f = (f_ptr_t)(g_func_table[242]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[295]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D8(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int);
     ON_ENTRY(cuMemsetD2D8);
-    f_ptr_t f = (f_ptr_t)(g_func_table[243]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[296]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D16(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int);
     ON_ENTRY(cuMemsetD2D16);
-    f_ptr_t f = (f_ptr_t)(g_func_table[244]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[297]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int);
     ON_ENTRY(cuMemsetD2D32);
-    f_ptr_t f = (f_ptr_t)(g_func_table[245]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[298]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuArrayCreate(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *);
     ON_ENTRY(cuArrayCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[246]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[299]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray);
     ON_ENTRY(cuArrayGetDescriptor);
-    f_ptr_t f = (f_ptr_t)(g_func_table[247]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[300]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuArray3DCreate(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *);
     ON_ENTRY(cuArray3DCreate);
-    f_ptr_t f = (f_ptr_t)(g_func_table[248]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[301]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray);
     ON_ENTRY(cuArray3DGetDescriptor);
-    f_ptr_t f = (f_ptr_t)(g_func_table[249]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[302]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetAddress(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int);
     ON_ENTRY(cuTexRefSetAddress);
-    f_ptr_t f = (f_ptr_t)(g_func_table[250]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[303]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int);
     ON_ENTRY(cuTexRefSetAddress2D);
-    f_ptr_t f = (f_ptr_t)(g_func_table[251]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[304]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuTexRefGetAddress(CUdeviceptr_v1 *arg0, CUtexref arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, CUtexref);
     ON_ENTRY(cuTexRefGetAddress);
-    f_ptr_t f = (f_ptr_t)(g_func_table[252]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[305]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource);
     ON_ENTRY(cuGraphicsResourceGetMappedPointer);
-    f_ptr_t f = (f_ptr_t)(g_func_table[253]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[306]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuCtxDestroy(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[254]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[307]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxPopCurrent(CUcontext *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
     ON_ENTRY(cuCtxPopCurrent);
-    f_ptr_t f = (f_ptr_t)(g_func_table[255]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[308]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuCtxPushCurrent(CUcontext arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
     ON_ENTRY(cuCtxPushCurrent);
-    f_ptr_t f = (f_ptr_t)(g_func_table[256]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[309]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuStreamDestroy(CUstream arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
     ON_ENTRY(cuStreamDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[257]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[310]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuEventDestroy(CUevent arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
     ON_ENTRY(cuEventDestroy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[258]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[311]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2(CUdeviceptr arg0, const void *arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
     ON_ENTRY(cuMemcpyHtoD_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[259]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[312]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2(void *arg0, CUdeviceptr arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpyDtoH_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[260]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[313]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpyDtoD_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[261]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[314]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpyDtoA_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[262]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[315]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
     ON_ENTRY(cuMemcpyAtoD_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[263]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[316]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
     ON_ENTRY(cuMemcpyHtoA_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[264]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[317]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
     ON_ENTRY(cuMemcpyAtoH_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[265]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[318]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
     ON_ENTRY(cuMemcpyAtoA_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[266]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[319]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
     ON_ENTRY(cuMemcpyHtoAAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[267]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[320]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
     ON_ENTRY(cuMemcpyAtoHAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[268]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[321]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2(const CUDA_MEMCPY2D *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
     ON_ENTRY(cuMemcpy2D_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[269]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[322]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
     ON_ENTRY(cuMemcpy2DUnaligned_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[270]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[323]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2(const CUDA_MEMCPY3D *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
     ON_ENTRY(cuMemcpy3D_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[271]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[324]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
     ON_ENTRY(cuMemcpyHtoDAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[272]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[325]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
     ON_ENTRY(cuMemcpyDtoHAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[273]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[326]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
     ON_ENTRY(cuMemcpyDtoDAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[274]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[327]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
     ON_ENTRY(cuMemcpy2DAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[275]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[328]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
     ON_ENTRY(cuMemcpy3DAsync_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[276]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[329]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD8_v2(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
     ON_ENTRY(cuMemsetD8_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[277]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[330]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD16_v2(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
     ON_ENTRY(cuMemsetD16_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[278]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[331]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD32_v2(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
     ON_ENTRY(cuMemsetD32_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[279]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[332]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
     ON_ENTRY(cuMemsetD2D8_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[280]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[333]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
     ON_ENTRY(cuMemsetD2D16_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[281]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[334]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
     ON_ENTRY(cuMemsetD2D32_v2);
-    f_ptr_t f = (f_ptr_t)(g_func_table[282]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[335]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
     ON_ENTRY(cuMemcpy);
-    f_ptr_t f = (f_ptr_t)(g_func_table[283]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[336]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyAsync(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
     ON_ENTRY(cuMemcpyAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[284]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[337]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyPeer(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
     ON_ENTRY(cuMemcpyPeer);
-    f_ptr_t f = (f_ptr_t)(g_func_table[285]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[338]);
     return f(arg0, arg1, arg2, arg3, arg4);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
     ON_ENTRY(cuMemcpyPeerAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[286]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[339]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
     ON_ENTRY(cuMemcpy3DPeer);
-    f_ptr_t f = (f_ptr_t)(g_func_table[287]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[340]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
     ON_ENTRY(cuMemcpy3DPeerAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[288]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[341]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD8Async(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
     ON_ENTRY(cuMemsetD8Async);
-    f_ptr_t f = (f_ptr_t)(g_func_table[289]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[342]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD16Async(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
     ON_ENTRY(cuMemsetD16Async);
-    f_ptr_t f = (f_ptr_t)(g_func_table[290]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[343]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD32Async(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
     ON_ENTRY(cuMemsetD32Async);
-    f_ptr_t f = (f_ptr_t)(g_func_table[291]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[344]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
     ON_ENTRY(cuMemsetD2D8Async);
-    f_ptr_t f = (f_ptr_t)(g_func_table[292]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[345]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
     ON_ENTRY(cuMemsetD2D16Async);
-    f_ptr_t f = (f_ptr_t)(g_func_table[293]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[346]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
     ON_ENTRY(cuMemsetD2D32Async);
-    f_ptr_t f = (f_ptr_t)(g_func_table[294]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[347]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5);
 }
 CUresult _WRAPLIB_API_CALL cuStreamGetPriority(CUstream arg0, int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
     ON_ENTRY(cuStreamGetPriority);
-    f_ptr_t f = (f_ptr_t)(g_func_table[295]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[348]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuStreamGetFlags(CUstream arg0, unsigned int *arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
     ON_ENTRY(cuStreamGetFlags);
-    f_ptr_t f = (f_ptr_t)(g_func_table[296]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[349]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[350]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuStreamWaitEvent(CUstream arg0, CUevent arg1, unsigned int arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
     ON_ENTRY(cuStreamWaitEvent);
-    f_ptr_t f = (f_ptr_t)(g_func_table[297]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[351]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuStreamAddCallback(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
     ON_ENTRY(cuStreamAddCallback);
-    f_ptr_t f = (f_ptr_t)(g_func_table[298]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[352]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
     ON_ENTRY(cuStreamAttachMemAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[299]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[353]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamQuery(CUstream arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
     ON_ENTRY(cuStreamQuery);
-    f_ptr_t f = (f_ptr_t)(g_func_table[300]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[354]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuStreamSynchronize(CUstream arg0) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
     ON_ENTRY(cuStreamSynchronize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[301]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[355]);
     return f(arg0);
 }
 CUresult _WRAPLIB_API_CALL cuEventRecord(CUevent arg0, CUstream arg1) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
     ON_ENTRY(cuEventRecord);
-    f_ptr_t f = (f_ptr_t)(g_func_table[302]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[356]);
     return f(arg0, arg1);
 }
 CUresult _WRAPLIB_API_CALL cuLaunchKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
     ON_ENTRY(cuLaunchKernel);
-    f_ptr_t f = (f_ptr_t)(g_func_table[303]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[357]);
     return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
 }
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[358]);
+    return f(arg0, arg1, arg2);
+}
 CUresult _WRAPLIB_API_CALL cuGraphicsMapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
     ON_ENTRY(cuGraphicsMapResources);
-    f_ptr_t f = (f_ptr_t)(g_func_table[304]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[359]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
     ON_ENTRY(cuGraphicsUnmapResources);
-    f_ptr_t f = (f_ptr_t)(g_func_table[305]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[360]);
     return f(arg0, arg1, arg2);
 }
-CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
-    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
-    ON_ENTRY(cuMemPrefetchAsync);
-    f_ptr_t f = (f_ptr_t)(g_func_table[306]);
-    return f(arg0, arg1, arg2, arg3);
-}
 CUresult _WRAPLIB_API_CALL cuStreamWriteValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
     ON_ENTRY(cuStreamWriteValue32);
-    f_ptr_t f = (f_ptr_t)(g_func_table[307]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[361]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamWaitValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
     ON_ENTRY(cuStreamWaitValue32);
-    f_ptr_t f = (f_ptr_t)(g_func_table[308]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[362]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[363]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[364]);
     return f(arg0, arg1, arg2, arg3);
 }
 CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
     ON_ENTRY(cuStreamBatchMemOp);
-    f_ptr_t f = (f_ptr_t)(g_func_table[309]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[365]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[366]);
     return f(arg0, arg1, arg2, arg3);
 }
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[367]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[368]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[369]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[370]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[371]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[372]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[373]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing);
+    f_ptr_t f = (f_ptr_t)(g_func_table[374]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[375]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[376]);
+    return f(arg0, arg1);
+}
 CUresult _WRAPLIB_API_CALL cuProfilerInitialize(const char *arg0, const char *arg1, CUoutput_mode arg2) {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const char *, const char *, CUoutput_mode);
     ON_ENTRY(cuProfilerInitialize);
-    f_ptr_t f = (f_ptr_t)(g_func_table[310]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[377]);
     return f(arg0, arg1, arg2);
 }
 CUresult _WRAPLIB_API_CALL cuProfilerStart() {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
     ON_ENTRY(cuProfilerStart);
-    f_ptr_t f = (f_ptr_t)(g_func_table[311]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[378]);
     return f();
 }
 CUresult _WRAPLIB_API_CALL cuProfilerStop() {
     typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
     ON_ENTRY(cuProfilerStop);
-    f_ptr_t f = (f_ptr_t)(g_func_table[312]);
+    f_ptr_t f = (f_ptr_t)(g_func_table[379]);
     return f();
 }
diff --git a/dnn/cuda-stub/src/libcuda-wrap_10.2.h b/dnn/cuda-stub/src/libcuda-wrap_10.2.h
new file mode 100644
index 0000000000000000000000000000000000000000..fbbc8eba8c8fd56b63426d7bb2e9d001fb4387e9
--- /dev/null
+++ b/dnn/cuda-stub/src/libcuda-wrap_10.2.h
@@ -0,0 +1,6398 @@
+// generated by wraplib.py
+// --- begin functions to be implemented
+#ifndef _WRAPLIB_API_CALL
+#define _WRAPLIB_API_CALL
+#endif
+#ifndef _WRAPLIB_CALLBACK
+#define _WRAPLIB_CALLBACK
+#endif
+#ifndef ON_ENTRY
+#define ON_ENTRY(x)
+#endif
+static void* get_library_handle();
+static void* resolve_library_func(void* , const char*);
+namespace {
+template<typename T> T on_init_failed(int func_idx);
+}
+// --- end functions to be implemented
+#include <mutex>
+#include <cstddef>
+static void load_library();
+static CUresult _WRAPLIB_API_CALL cuGetErrorString_init(CUresult arg0, const char **arg1) {
+    load_library();
+    return cuGetErrorString(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorString_error(CUresult, const char **) {
+    return on_init_failed<CUresult >(0);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorName_init(CUresult arg0, const char **arg1) {
+    load_library();
+    return cuGetErrorName(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorName_error(CUresult, const char **) {
+    return on_init_failed<CUresult >(1);
+}
+static CUresult _WRAPLIB_API_CALL cuInit_init(unsigned int arg0) {
+    load_library();
+    return cuInit(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuInit_error(unsigned int) {
+    return on_init_failed<CUresult >(2);
+}
+static CUresult _WRAPLIB_API_CALL cuDriverGetVersion_init(int *arg0) {
+    load_library();
+    return cuDriverGetVersion(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDriverGetVersion_error(int *) {
+    return on_init_failed<CUresult >(3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGet_init(CUdevice *arg0, int arg1) {
+    load_library();
+    return cuDeviceGet(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGet_error(CUdevice *, int) {
+    return on_init_failed<CUresult >(4);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetCount_init(int *arg0) {
+    load_library();
+    return cuDeviceGetCount(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetCount_error(int *) {
+    return on_init_failed<CUresult >(5);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetName_init(char *arg0, int arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetName(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetName_error(char *, int, CUdevice) {
+    return on_init_failed<CUresult >(6);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_init(CUuuid *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetUuid(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_error(CUuuid *, CUdevice) {
+    return on_init_failed<CUresult >(7);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_init(size_t *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceTotalMem_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_error(size_t *, CUdevice) {
+    return on_init_failed<CUresult >(8);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_init(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_error(int *, CUdevice_attribute, CUdevice) {
+    return on_init_failed<CUresult >(9);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes_init(void *arg0, CUdevice arg1, int arg2) {
+    load_library();
+    return cuDeviceGetNvSciSyncAttributes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes_error(void *, CUdevice, int) {
+    return on_init_failed<CUresult >(10);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_init(CUdevprop *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_error(CUdevprop *, CUdevice) {
+    return on_init_failed<CUresult >(11);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_init(int *arg0, int *arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceComputeCapability(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_error(int *, int *, CUdevice) {
+    return on_init_failed<CUresult >(12);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_init(CUcontext *arg0, CUdevice arg1) {
+    load_library();
+    return cuDevicePrimaryCtxRetain(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_error(CUcontext *, CUdevice) {
+    return on_init_failed<CUresult >(13);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxRelease(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_error(CUdevice) {
+    return on_init_failed<CUresult >(14);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_init(CUdevice arg0, unsigned int arg1) {
+    load_library();
+    return cuDevicePrimaryCtxSetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_error(CUdevice, unsigned int) {
+    return on_init_failed<CUresult >(15);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_init(CUdevice arg0, unsigned int *arg1, int *arg2) {
+    load_library();
+    return cuDevicePrimaryCtxGetState(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_error(CUdevice, unsigned int *, int *) {
+    return on_init_failed<CUresult >(16);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxReset(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_error(CUdevice) {
+    return on_init_failed<CUresult >(17);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    load_library();
+    return cuCtxCreate_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_error(CUcontext *, unsigned int, CUdevice) {
+    return on_init_failed<CUresult >(18);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_error(CUcontext) {
+    return on_init_failed<CUresult >(19);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_init(CUcontext arg0) {
+    load_library();
+    return cuCtxPushCurrent_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_error(CUcontext) {
+    return on_init_failed<CUresult >(20);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxPopCurrent_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_error(CUcontext *) {
+    return on_init_failed<CUresult >(21);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_init(CUcontext arg0) {
+    load_library();
+    return cuCtxSetCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_error(CUcontext) {
+    return on_init_failed<CUresult >(22);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxGetCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_error(CUcontext *) {
+    return on_init_failed<CUresult >(23);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_init(CUdevice *arg0) {
+    load_library();
+    return cuCtxGetDevice(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_error(CUdevice *) {
+    return on_init_failed<CUresult >(24);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_init(unsigned int *arg0) {
+    load_library();
+    return cuCtxGetFlags(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_error(unsigned int *) {
+    return on_init_failed<CUresult >(25);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_init() {
+    load_library();
+    return cuCtxSynchronize();
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_error() {
+    return on_init_failed<CUresult >(26);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_init(CUlimit arg0, size_t arg1) {
+    load_library();
+    return cuCtxSetLimit(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_error(CUlimit, size_t) {
+    return on_init_failed<CUresult >(27);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_init(size_t *arg0, CUlimit arg1) {
+    load_library();
+    return cuCtxGetLimit(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_error(size_t *, CUlimit) {
+    return on_init_failed<CUresult >(28);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_init(CUfunc_cache *arg0) {
+    load_library();
+    return cuCtxGetCacheConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_error(CUfunc_cache *) {
+    return on_init_failed<CUresult >(29);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_init(CUfunc_cache arg0) {
+    load_library();
+    return cuCtxSetCacheConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_error(CUfunc_cache) {
+    return on_init_failed<CUresult >(30);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_init(CUsharedconfig *arg0) {
+    load_library();
+    return cuCtxGetSharedMemConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_error(CUsharedconfig *) {
+    return on_init_failed<CUresult >(31);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_init(CUsharedconfig arg0) {
+    load_library();
+    return cuCtxSetSharedMemConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_error(CUsharedconfig) {
+    return on_init_failed<CUresult >(32);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_init(CUcontext arg0, unsigned int *arg1) {
+    load_library();
+    return cuCtxGetApiVersion(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_error(CUcontext, unsigned int *) {
+    return on_init_failed<CUresult >(33);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_init(int *arg0, int *arg1) {
+    load_library();
+    return cuCtxGetStreamPriorityRange(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_error(int *, int *) {
+    return on_init_failed<CUresult >(34);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxAttach_init(CUcontext *arg0, unsigned int arg1) {
+    load_library();
+    return cuCtxAttach(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxAttach_error(CUcontext *, unsigned int) {
+    return on_init_failed<CUresult >(35);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDetach_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDetach(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDetach_error(CUcontext) {
+    return on_init_failed<CUresult >(36);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoad_init(CUmodule *arg0, const char *arg1) {
+    load_library();
+    return cuModuleLoad(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoad_error(CUmodule *, const char *) {
+    return on_init_failed<CUresult >(37);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadData_init(CUmodule *arg0, const void *arg1) {
+    load_library();
+    return cuModuleLoadData(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadData_error(CUmodule *, const void *) {
+    return on_init_failed<CUresult >(38);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_init(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
+    load_library();
+    return cuModuleLoadDataEx(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_error(CUmodule *, const void *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(39);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_init(CUmodule *arg0, const void *arg1) {
+    load_library();
+    return cuModuleLoadFatBinary(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_error(CUmodule *, const void *) {
+    return on_init_failed<CUresult >(40);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleUnload_init(CUmodule arg0) {
+    load_library();
+    return cuModuleUnload(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleUnload_error(CUmodule) {
+    return on_init_failed<CUresult >(41);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_init(CUfunction *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetFunction(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_error(CUfunction *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(42);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_init(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
+    load_library();
+    return cuModuleGetGlobal_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_error(CUdeviceptr *, size_t *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(43);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_init(CUtexref *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetTexRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_error(CUtexref *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(44);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_init(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetSurfRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_error(CUsurfref *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(45);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    load_library();
+    return cuLinkCreate_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
+    return on_init_failed<CUresult >(46);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    load_library();
+    return cuLinkAddData_v2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(47);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    load_library();
+    return cuLinkAddFile_v2(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(48);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkComplete_init(CUlinkState arg0, void **arg1, size_t *arg2) {
+    load_library();
+    return cuLinkComplete(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkComplete_error(CUlinkState, void **, size_t *) {
+    return on_init_failed<CUresult >(49);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkDestroy_init(CUlinkState arg0) {
+    load_library();
+    return cuLinkDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkDestroy_error(CUlinkState) {
+    return on_init_failed<CUresult >(50);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_init(size_t *arg0, size_t *arg1) {
+    load_library();
+    return cuMemGetInfo_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_error(size_t *, size_t *) {
+    return on_init_failed<CUresult >(51);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_init(CUdeviceptr *arg0, size_t arg1) {
+    load_library();
+    return cuMemAlloc_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_error(CUdeviceptr *, size_t) {
+    return on_init_failed<CUresult >(52);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_init(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
+    load_library();
+    return cuMemAllocPitch_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_error(CUdeviceptr *, size_t *, size_t, size_t, unsigned int) {
+    return on_init_failed<CUresult >(53);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_v2_init(CUdeviceptr arg0) {
+    load_library();
+    return cuMemFree_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_v2_error(CUdeviceptr) {
+    return on_init_failed<CUresult >(54);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_init(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuMemGetAddressRange_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_error(CUdeviceptr *, size_t *, CUdeviceptr) {
+    return on_init_failed<CUresult >(55);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_init(void **arg0, size_t arg1) {
+    load_library();
+    return cuMemAllocHost_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_error(void **, size_t) {
+    return on_init_failed<CUresult >(56);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeHost_init(void *arg0) {
+    load_library();
+    return cuMemFreeHost(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeHost_error(void *) {
+    return on_init_failed<CUresult >(57);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_init(void **arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostAlloc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_error(void **, size_t, unsigned int) {
+    return on_init_failed<CUresult >(58);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_init(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostGetDevicePointer_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_error(CUdeviceptr *, void *, unsigned int) {
+    return on_init_failed<CUresult >(59);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_init(unsigned int *arg0, void *arg1) {
+    load_library();
+    return cuMemHostGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_error(unsigned int *, void *) {
+    return on_init_failed<CUresult >(60);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_init(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemAllocManaged(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_error(CUdeviceptr *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(61);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_init(CUdevice *arg0, const char *arg1) {
+    load_library();
+    return cuDeviceGetByPCIBusId(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_error(CUdevice *, const char *) {
+    return on_init_failed<CUresult >(62);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_init(char *arg0, int arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetPCIBusId(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_error(char *, int, CUdevice) {
+    return on_init_failed<CUresult >(63);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_init(CUipcEventHandle *arg0, CUevent arg1) {
+    load_library();
+    return cuIpcGetEventHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_error(CUipcEventHandle *, CUevent) {
+    return on_init_failed<CUresult >(64);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_init(CUevent *arg0, CUipcEventHandle arg1) {
+    load_library();
+    return cuIpcOpenEventHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_error(CUevent *, CUipcEventHandle) {
+    return on_init_failed<CUresult >(65);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_init(CUipcMemHandle *arg0, CUdeviceptr arg1) {
+    load_library();
+    return cuIpcGetMemHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_error(CUipcMemHandle *, CUdeviceptr) {
+    return on_init_failed<CUresult >(66);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_init(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    load_library();
+    return cuIpcOpenMemHandle(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_error(CUdeviceptr *, CUipcMemHandle, unsigned int) {
+    return on_init_failed<CUresult >(67);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_init(CUdeviceptr arg0) {
+    load_library();
+    return cuIpcCloseMemHandle(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_error(CUdeviceptr) {
+    return on_init_failed<CUresult >(68);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_init(void *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostRegister_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_error(void *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(69);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_init(void *arg0) {
+    load_library();
+    return cuMemHostUnregister(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_error(void *) {
+    return on_init_failed<CUresult >(70);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpy_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(71);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyPeer_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
+    return on_init_failed<CUresult >(72);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyHtoD_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_error(CUdeviceptr, const void *, size_t) {
+    return on_init_failed<CUresult >(73);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoH_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_error(void *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(74);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoD_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(75);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyDtoA_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_error(CUarray, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(76);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoD_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_error(CUdeviceptr, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(77);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyHtoA_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_error(CUarray, size_t, const void *, size_t) {
+    return on_init_failed<CUresult >(78);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoH_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_error(void *, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(79);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyAtoA_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_error(CUarray, size_t, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(80);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2D_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(81);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(82);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_init(const CUDA_MEMCPY3D *arg0) {
+    load_library();
+    return cuMemcpy3D_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_error(const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(83);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_init(const CUDA_MEMCPY3D_PEER *arg0) {
+    load_library();
+    return cuMemcpy3DPeer_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_error(const CUDA_MEMCPY3D_PEER *) {
+    return on_init_failed<CUresult >(84);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(85);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemcpyPeerAsync_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
+    return on_init_failed<CUresult >(86);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_error(CUdeviceptr, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(87);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_error(void *, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(88);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(89);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_error(CUarray, size_t, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(90);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_error(void *, CUarray, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(91);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_error(const CUDA_MEMCPY2D *, CUstream) {
+    return on_init_failed<CUresult >(92);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_error(const CUDA_MEMCPY3D *, CUstream) {
+    return on_init_failed<CUresult >(93);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DPeerAsync_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
+    return on_init_failed<CUresult >(94);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD8_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_error(CUdeviceptr, unsigned char, size_t) {
+    return on_init_failed<CUresult >(95);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD16_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_error(CUdeviceptr, unsigned short, size_t) {
+    return on_init_failed<CUresult >(96);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD32_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_error(CUdeviceptr, unsigned int, size_t) {
+    return on_init_failed<CUresult >(97);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D8_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
+    return on_init_failed<CUresult >(98);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D16_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
+    return on_init_failed<CUresult >(99);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D32_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
+    return on_init_failed<CUresult >(100);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD8Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_error(CUdeviceptr, unsigned char, size_t, CUstream) {
+    return on_init_failed<CUresult >(101);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD16Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_error(CUdeviceptr, unsigned short, size_t, CUstream) {
+    return on_init_failed<CUresult >(102);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD32Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_error(CUdeviceptr, unsigned int, size_t, CUstream) {
+    return on_init_failed<CUresult >(103);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D8Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(104);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D16Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(105);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D32Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(106);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
+    load_library();
+    return cuArrayCreate_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR *) {
+    return on_init_failed<CUresult >(107);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_init(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetDescriptor_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_error(CUDA_ARRAY_DESCRIPTOR *, CUarray) {
+    return on_init_failed<CUresult >(108);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayDestroy_init(CUarray arg0) {
+    load_library();
+    return cuArrayDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayDestroy_error(CUarray) {
+    return on_init_failed<CUresult >(109);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
+    load_library();
+    return cuArray3DCreate_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *) {
+    return on_init_failed<CUresult >(110);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_init(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
+    load_library();
+    return cuArray3DGetDescriptor_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_error(CUDA_ARRAY3D_DESCRIPTOR *, CUarray) {
+    return on_init_failed<CUresult >(111);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_init(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
+    load_library();
+    return cuMipmappedArrayCreate(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_error(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int) {
+    return on_init_failed<CUresult >(112);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_init(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    load_library();
+    return cuMipmappedArrayGetLevel(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_error(CUarray *, CUmipmappedArray, unsigned int) {
+    return on_init_failed<CUresult >(113);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_init(CUmipmappedArray arg0) {
+    load_library();
+    return cuMipmappedArrayDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_error(CUmipmappedArray) {
+    return on_init_failed<CUresult >(114);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressReserve_init(CUdeviceptr *arg0, size_t arg1, size_t arg2, CUdeviceptr arg3, unsigned long long arg4) {
+    load_library();
+    return cuMemAddressReserve(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressReserve_error(CUdeviceptr *, size_t, size_t, CUdeviceptr, unsigned long long) {
+    return on_init_failed<CUresult >(115);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressFree_init(CUdeviceptr arg0, size_t arg1) {
+    load_library();
+    return cuMemAddressFree(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressFree_error(CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(116);
+}
+static CUresult _WRAPLIB_API_CALL cuMemCreate_init(CUmemGenericAllocationHandle *arg0, size_t arg1, const CUmemAllocationProp *arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemCreate_error(CUmemGenericAllocationHandle *, size_t, const CUmemAllocationProp *, unsigned long long) {
+    return on_init_failed<CUresult >(117);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRelease_init(CUmemGenericAllocationHandle arg0) {
+    load_library();
+    return cuMemRelease(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRelease_error(CUmemGenericAllocationHandle) {
+    return on_init_failed<CUresult >(118);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMap_init(CUdeviceptr arg0, size_t arg1, size_t arg2, CUmemGenericAllocationHandle arg3, unsigned long long arg4) {
+    load_library();
+    return cuMemMap(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMap_error(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long) {
+    return on_init_failed<CUresult >(119);
+}
+static CUresult _WRAPLIB_API_CALL cuMemUnmap_init(CUdeviceptr arg0, size_t arg1) {
+    load_library();
+    return cuMemUnmap(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemUnmap_error(CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(120);
+}
+static CUresult _WRAPLIB_API_CALL cuMemSetAccess_init(CUdeviceptr arg0, size_t arg1, const CUmemAccessDesc *arg2, size_t arg3) {
+    load_library();
+    return cuMemSetAccess(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemSetAccess_error(CUdeviceptr, size_t, const CUmemAccessDesc *, size_t) {
+    return on_init_failed<CUresult >(121);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAccess_init(unsigned long long *arg0, const CUmemLocation *arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuMemGetAccess(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAccess_error(unsigned long long *, const CUmemLocation *, CUdeviceptr) {
+    return on_init_failed<CUresult >(122);
+}
+static CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle_init(void *arg0, CUmemGenericAllocationHandle arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemExportToShareableHandle(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle_error(void *, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long) {
+    return on_init_failed<CUresult >(123);
+}
+static CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle_init(CUmemGenericAllocationHandle *arg0, void *arg1, CUmemAllocationHandleType arg2) {
+    load_library();
+    return cuMemImportFromShareableHandle(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle_error(CUmemGenericAllocationHandle *, void *, CUmemAllocationHandleType) {
+    return on_init_failed<CUresult >(124);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity_init(size_t *arg0, const CUmemAllocationProp *arg1, CUmemAllocationGranularity_flags arg2) {
+    load_library();
+    return cuMemGetAllocationGranularity(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity_error(size_t *, const CUmemAllocationProp *, CUmemAllocationGranularity_flags) {
+    return on_init_failed<CUresult >(125);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle_init(CUmemAllocationProp *arg0, CUmemGenericAllocationHandle arg1) {
+    load_library();
+    return cuMemGetAllocationPropertiesFromHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle_error(CUmemAllocationProp *, CUmemGenericAllocationHandle) {
+    return on_init_failed<CUresult >(126);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_init(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuPointerGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_error(void *, CUpointer_attribute, CUdeviceptr) {
+    return on_init_failed<CUresult >(127);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(128);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAdvise_init(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
+    load_library();
+    return cuMemAdvise(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAdvise_error(CUdeviceptr, size_t, CUmem_advise, CUdevice) {
+    return on_init_failed<CUresult >(129);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_init(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
+    load_library();
+    return cuMemRangeGetAttribute(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_error(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(130);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_init(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
+    load_library();
+    return cuMemRangeGetAttributes(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_error(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(131);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_init(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuPointerSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_error(const void *, CUpointer_attribute, CUdeviceptr) {
+    return on_init_failed<CUresult >(132);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_init(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
+    load_library();
+    return cuPointerGetAttributes(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_error(unsigned int, CUpointer_attribute *, void **, CUdeviceptr) {
+    return on_init_failed<CUresult >(133);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreate_init(CUstream *arg0, unsigned int arg1) {
+    load_library();
+    return cuStreamCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreate_error(CUstream *, unsigned int) {
+    return on_init_failed<CUresult >(134);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_init(CUstream *arg0, unsigned int arg1, int arg2) {
+    load_library();
+    return cuStreamCreateWithPriority(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_error(CUstream *, unsigned int, int) {
+    return on_init_failed<CUresult >(135);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_init(CUstream arg0, int *arg1) {
+    load_library();
+    return cuStreamGetPriority_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_error(CUstream, int *) {
+    return on_init_failed<CUresult >(136);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_init(CUstream arg0, unsigned int *arg1) {
+    load_library();
+    return cuStreamGetFlags_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_error(CUstream, unsigned int *) {
+    return on_init_failed<CUresult >(137);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(138);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    load_library();
+    return cuStreamWaitEvent_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_error(CUstream, CUevent, unsigned int) {
+    return on_init_failed<CUresult >(139);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAddCallback_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_error(CUstream, CUstreamCallback, void *, unsigned int) {
+    return on_init_failed<CUresult >(140);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(141);
+}
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_init(CUstreamCaptureMode *arg0) {
+    load_library();
+    return cuThreadExchangeStreamCaptureMode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_error(CUstreamCaptureMode *) {
+    return on_init_failed<CUresult >(142);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(143);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(144);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(145);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(146);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(147);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamSynchronize_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(148);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_init(CUstream arg0) {
+    load_library();
+    return cuStreamDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_error(CUstream) {
+    return on_init_failed<CUresult >(149);
+}
+static CUresult _WRAPLIB_API_CALL cuEventCreate_init(CUevent *arg0, unsigned int arg1) {
+    load_library();
+    return cuEventCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventCreate_error(CUevent *, unsigned int) {
+    return on_init_failed<CUresult >(150);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_init(CUevent arg0, CUstream arg1) {
+    load_library();
+    return cuEventRecord_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_error(CUevent, CUstream) {
+    return on_init_failed<CUresult >(151);
+}
+static CUresult _WRAPLIB_API_CALL cuEventQuery_init(CUevent arg0) {
+    load_library();
+    return cuEventQuery(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventQuery_error(CUevent) {
+    return on_init_failed<CUresult >(152);
+}
+static CUresult _WRAPLIB_API_CALL cuEventSynchronize_init(CUevent arg0) {
+    load_library();
+    return cuEventSynchronize(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventSynchronize_error(CUevent) {
+    return on_init_failed<CUresult >(153);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_init(CUevent arg0) {
+    load_library();
+    return cuEventDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_error(CUevent) {
+    return on_init_failed<CUresult >(154);
+}
+static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_init(float *arg0, CUevent arg1, CUevent arg2) {
+    load_library();
+    return cuEventElapsedTime(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_error(float *, CUevent, CUevent) {
+    return on_init_failed<CUresult >(155);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_init(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalMemory(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_error(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(156);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_init(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedBuffer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_error(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *) {
+    return on_init_failed<CUresult >(157);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_error(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *) {
+    return on_init_failed<CUresult >(158);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_init(CUexternalMemory arg0) {
+    load_library();
+    return cuDestroyExternalMemory(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_error(CUexternalMemory) {
+    return on_init_failed<CUresult >(159);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_init(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalSemaphore(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_error(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(160);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(161);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(162);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_init(CUexternalSemaphore arg0) {
+    load_library();
+    return cuDestroyExternalSemaphore(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_error(CUexternalSemaphore) {
+    return on_init_failed<CUresult >(163);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue32_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(164);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(165);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue32_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(166);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(167);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamBatchMemOp_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
+    return on_init_failed<CUresult >(168);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_init(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
+    load_library();
+    return cuFuncGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_error(int *, CUfunction_attribute, CUfunction) {
+    return on_init_failed<CUresult >(169);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_init(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    load_library();
+    return cuFuncSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_error(CUfunction, CUfunction_attribute, int) {
+    return on_init_failed<CUresult >(170);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_init(CUfunction arg0, CUfunc_cache arg1) {
+    load_library();
+    return cuFuncSetCacheConfig(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_error(CUfunction, CUfunc_cache) {
+    return on_init_failed<CUresult >(171);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_init(CUfunction arg0, CUsharedconfig arg1) {
+    load_library();
+    return cuFuncSetSharedMemConfig(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_error(CUfunction, CUsharedconfig) {
+    return on_init_failed<CUresult >(172);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    load_library();
+    return cuLaunchKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
+    return on_init_failed<CUresult >(173);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(174);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_init(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuLaunchCooperativeKernelMultiDevice(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_error(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(175);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(176);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_init(CUfunction arg0, int arg1, int arg2, int arg3) {
+    load_library();
+    return cuFuncSetBlockShape(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_error(CUfunction, int, int, int) {
+    return on_init_failed<CUresult >(177);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_init(CUfunction arg0, unsigned int arg1) {
+    load_library();
+    return cuFuncSetSharedSize(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_error(CUfunction, unsigned int) {
+    return on_init_failed<CUresult >(178);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetSize_init(CUfunction arg0, unsigned int arg1) {
+    load_library();
+    return cuParamSetSize(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetSize_error(CUfunction, unsigned int) {
+    return on_init_failed<CUresult >(179);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSeti_init(CUfunction arg0, int arg1, unsigned int arg2) {
+    load_library();
+    return cuParamSeti(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSeti_error(CUfunction, int, unsigned int) {
+    return on_init_failed<CUresult >(180);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetf_init(CUfunction arg0, int arg1, float arg2) {
+    load_library();
+    return cuParamSetf(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetf_error(CUfunction, int, float) {
+    return on_init_failed<CUresult >(181);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetv_init(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuParamSetv(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetv_error(CUfunction, int, void *, unsigned int) {
+    return on_init_failed<CUresult >(182);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunch_init(CUfunction arg0) {
+    load_library();
+    return cuLaunch(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunch_error(CUfunction) {
+    return on_init_failed<CUresult >(183);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGrid_init(CUfunction arg0, int arg1, int arg2) {
+    load_library();
+    return cuLaunchGrid(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGrid_error(CUfunction, int, int) {
+    return on_init_failed<CUresult >(184);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_init(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
+    load_library();
+    return cuLaunchGridAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_error(CUfunction, int, int, CUstream) {
+    return on_init_failed<CUresult >(185);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_init(CUfunction arg0, int arg1, CUtexref arg2) {
+    load_library();
+    return cuParamSetTexRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_error(CUfunction, int, CUtexref) {
+    return on_init_failed<CUresult >(186);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_init(CUgraph *arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_error(CUgraph *, unsigned int) {
+    return on_init_failed<CUresult >(187);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddKernelNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(188);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_init(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_error(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(189);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_init(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_error(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(190);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemcpyNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(191);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_init(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_error(CUgraphNode, CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(192);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_error(CUgraphNode, const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(193);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemsetNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(194);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_init(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_error(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(195);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_error(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(196);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddHostNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(197);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_init(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_error(CUgraphNode, CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(198);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_init(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_error(CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(199);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    load_library();
+    return cuGraphAddChildGraphNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph) {
+    return on_init_failed<CUresult >(200);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_init(CUgraphNode arg0, CUgraph *arg1) {
+    load_library();
+    return cuGraphChildGraphNodeGetGraph(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_error(CUgraphNode, CUgraph *) {
+    return on_init_failed<CUresult >(201);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddEmptyNode(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(202);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_init(CUgraph *arg0, CUgraph arg1) {
+    load_library();
+    return cuGraphClone(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_error(CUgraph *, CUgraph) {
+    return on_init_failed<CUresult >(203);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_init(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    load_library();
+    return cuGraphNodeFindInClone(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_error(CUgraphNode *, CUgraphNode, CUgraph) {
+    return on_init_failed<CUresult >(204);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_init(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    load_library();
+    return cuGraphNodeGetType(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_error(CUgraphNode, CUgraphNodeType *) {
+    return on_init_failed<CUresult >(205);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(206);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetRootNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(207);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_init(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    load_library();
+    return cuGraphGetEdges(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_error(CUgraph, CUgraphNode *, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(208);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependencies(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(209);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependentNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(210);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(211);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphRemoveDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(212);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_init(CUgraphNode arg0) {
+    load_library();
+    return cuGraphDestroyNode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_error(CUgraphNode) {
+    return on_init_failed<CUresult >(213);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_init(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    load_library();
+    return cuGraphInstantiate(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_error(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t) {
+    return on_init_failed<CUresult >(214);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecKernelNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(215);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMCPY3D *arg2, CUcontext arg3) {
+    load_library();
+    return cuGraphExecMemcpyNodeSetParams(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(216);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMSET_NODE_PARAMS *arg2, CUcontext arg3) {
+    load_library();
+    return cuGraphExecMemsetNodeSetParams(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(217);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_HOST_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecHostNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(218);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(219);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_init(CUgraphExec arg0) {
+    load_library();
+    return cuGraphExecDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_error(CUgraphExec) {
+    return on_init_failed<CUresult >(220);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_init(CUgraph arg0) {
+    load_library();
+    return cuGraphDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_error(CUgraph) {
+    return on_init_failed<CUresult >(221);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecUpdate_init(CUgraphExec arg0, CUgraph arg1, CUgraphNode *arg2, CUgraphExecUpdateResult *arg3) {
+    load_library();
+    return cuGraphExecUpdate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecUpdate_error(CUgraphExec, CUgraph, CUgraphNode *, CUgraphExecUpdateResult *) {
+    return on_init_failed<CUresult >(222);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_init(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
+    load_library();
+    return cuOccupancyMaxActiveBlocksPerMultiprocessor(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_error(int *, CUfunction, int, size_t) {
+    return on_init_failed<CUresult >(223);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
+    load_library();
+    return cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error(int *, CUfunction, int, size_t, unsigned int) {
+    return on_init_failed<CUresult >(224);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
+    load_library();
+    return cuOccupancyMaxPotentialBlockSize(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int) {
+    return on_init_failed<CUresult >(225);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
+    load_library();
+    return cuOccupancyMaxPotentialBlockSizeWithFlags(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int) {
+    return on_init_failed<CUresult >(226);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_init(CUtexref arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuTexRefSetArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_error(CUtexref, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(227);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_init(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    load_library();
+    return cuTexRefSetMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_error(CUtexref, CUmipmappedArray, unsigned int) {
+    return on_init_failed<CUresult >(228);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_init(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_error(size_t *, CUtexref, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(229);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress2D_v3(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(230);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_init(CUtexref arg0, CUarray_format arg1, int arg2) {
+    load_library();
+    return cuTexRefSetFormat(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_error(CUtexref, CUarray_format, int) {
+    return on_init_failed<CUresult >(231);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_init(CUtexref arg0, int arg1, CUaddress_mode arg2) {
+    load_library();
+    return cuTexRefSetAddressMode(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_error(CUtexref, int, CUaddress_mode) {
+    return on_init_failed<CUresult >(232);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
+    load_library();
+    return cuTexRefSetFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_error(CUtexref, CUfilter_mode) {
+    return on_init_failed<CUresult >(233);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
+    load_library();
+    return cuTexRefSetMipmapFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_error(CUtexref, CUfilter_mode) {
+    return on_init_failed<CUresult >(234);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_init(CUtexref arg0, float arg1) {
+    load_library();
+    return cuTexRefSetMipmapLevelBias(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_error(CUtexref, float) {
+    return on_init_failed<CUresult >(235);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_init(CUtexref arg0, float arg1, float arg2) {
+    load_library();
+    return cuTexRefSetMipmapLevelClamp(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_error(CUtexref, float, float) {
+    return on_init_failed<CUresult >(236);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_init(CUtexref arg0, unsigned int arg1) {
+    load_library();
+    return cuTexRefSetMaxAnisotropy(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_error(CUtexref, unsigned int) {
+    return on_init_failed<CUresult >(237);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_init(CUtexref arg0, float *arg1) {
+    load_library();
+    return cuTexRefSetBorderColor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_error(CUtexref, float *) {
+    return on_init_failed<CUresult >(238);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_init(CUtexref arg0, unsigned int arg1) {
+    load_library();
+    return cuTexRefSetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_error(CUtexref, unsigned int) {
+    return on_init_failed<CUresult >(239);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_init(CUdeviceptr *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetAddress_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_error(CUdeviceptr *, CUtexref) {
+    return on_init_failed<CUresult >(240);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_init(CUarray *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_error(CUarray *, CUtexref) {
+    return on_init_failed<CUresult >(241);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_init(CUmipmappedArray *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmappedArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_error(CUmipmappedArray *, CUtexref) {
+    return on_init_failed<CUresult >(242);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_init(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
+    load_library();
+    return cuTexRefGetAddressMode(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_error(CUaddress_mode *, CUtexref, int) {
+    return on_init_failed<CUresult >(243);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_error(CUfilter_mode *, CUtexref) {
+    return on_init_failed<CUresult >(244);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_init(CUarray_format *arg0, int *arg1, CUtexref arg2) {
+    load_library();
+    return cuTexRefGetFormat(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_error(CUarray_format *, int *, CUtexref) {
+    return on_init_failed<CUresult >(245);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmapFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_error(CUfilter_mode *, CUtexref) {
+    return on_init_failed<CUresult >(246);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_init(float *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmapLevelBias(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_error(float *, CUtexref) {
+    return on_init_failed<CUresult >(247);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_init(float *arg0, float *arg1, CUtexref arg2) {
+    load_library();
+    return cuTexRefGetMipmapLevelClamp(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_error(float *, float *, CUtexref) {
+    return on_init_failed<CUresult >(248);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_init(int *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMaxAnisotropy(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_error(int *, CUtexref) {
+    return on_init_failed<CUresult >(249);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_init(float *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetBorderColor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_error(float *, CUtexref) {
+    return on_init_failed<CUresult >(250);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_init(unsigned int *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_error(unsigned int *, CUtexref) {
+    return on_init_failed<CUresult >(251);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefCreate_init(CUtexref *arg0) {
+    load_library();
+    return cuTexRefCreate(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefCreate_error(CUtexref *) {
+    return on_init_failed<CUresult >(252);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_init(CUtexref arg0) {
+    load_library();
+    return cuTexRefDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_error(CUtexref) {
+    return on_init_failed<CUresult >(253);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_init(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuSurfRefSetArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_error(CUsurfref, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(254);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_init(CUarray *arg0, CUsurfref arg1) {
+    load_library();
+    return cuSurfRefGetArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_error(CUarray *, CUsurfref) {
+    return on_init_failed<CUresult >(255);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_init(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
+    load_library();
+    return cuTexObjectCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_error(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *) {
+    return on_init_failed<CUresult >(256);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_init(CUtexObject arg0) {
+    load_library();
+    return cuTexObjectDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_error(CUtexObject) {
+    return on_init_failed<CUresult >(257);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetResourceDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(258);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_init(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetTextureDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_error(CUDA_TEXTURE_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(259);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_init(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetResourceViewDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_error(CUDA_RESOURCE_VIEW_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(260);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_init(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
+    load_library();
+    return cuSurfObjectCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_error(CUsurfObject *, const CUDA_RESOURCE_DESC *) {
+    return on_init_failed<CUresult >(261);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_init(CUsurfObject arg0) {
+    load_library();
+    return cuSurfObjectDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_error(CUsurfObject) {
+    return on_init_failed<CUresult >(262);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
+    load_library();
+    return cuSurfObjectGetResourceDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUsurfObject) {
+    return on_init_failed<CUresult >(263);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_init(int *arg0, CUdevice arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceCanAccessPeer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_error(int *, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(264);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_init(CUcontext arg0, unsigned int arg1) {
+    load_library();
+    return cuCtxEnablePeerAccess(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_error(CUcontext, unsigned int) {
+    return on_init_failed<CUresult >(265);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDisablePeerAccess(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_error(CUcontext) {
+    return on_init_failed<CUresult >(266);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_init(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    load_library();
+    return cuDeviceGetP2PAttribute(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_error(int *, CUdevice_P2PAttribute, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(267);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_init(CUgraphicsResource arg0) {
+    load_library();
+    return cuGraphicsUnregisterResource(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_error(CUgraphicsResource) {
+    return on_init_failed<CUresult >(268);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_init(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuGraphicsSubResourceGetMappedArray(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_error(CUarray *, CUgraphicsResource, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(269);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
+    load_library();
+    return cuGraphicsResourceGetMappedMipmappedArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_error(CUmipmappedArray *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(270);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_init(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
+    load_library();
+    return cuGraphicsResourceGetMappedPointer_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_error(CUdeviceptr *, size_t *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(271);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_init(CUgraphicsResource arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphicsResourceSetMapFlags_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_error(CUgraphicsResource, unsigned int) {
+    return on_init_failed<CUresult >(272);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsMapResources_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(273);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsUnmapResources_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(274);
+}
+static CUresult _WRAPLIB_API_CALL cuGetExportTable_init(const void **arg0, const CUuuid *arg1) {
+    load_library();
+    return cuGetExportTable(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetExportTable_error(const void **, const CUuuid *) {
+    return on_init_failed<CUresult >(275);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_init(void *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostRegister(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_error(void *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(276);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_init(CUgraphicsResource arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphicsResourceSetMapFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_error(CUgraphicsResource, unsigned int) {
+    return on_init_failed<CUresult >(277);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    load_library();
+    return cuLinkCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
+    return on_init_failed<CUresult >(278);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    load_library();
+    return cuLinkAddData(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(279);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    load_library();
+    return cuLinkAddFile(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(280);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress2D_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(281);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_init(unsigned int *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceTotalMem(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_error(unsigned int *, CUdevice) {
+    return on_init_failed<CUresult >(282);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    load_library();
+    return cuCtxCreate(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_error(CUcontext *, unsigned int, CUdevice) {
+    return on_init_failed<CUresult >(283);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
+    load_library();
+    return cuModuleGetGlobal(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_error(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(284);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_init(unsigned int *arg0, unsigned int *arg1) {
+    load_library();
+    return cuMemGetInfo(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_error(unsigned int *, unsigned int *) {
+    return on_init_failed<CUresult >(285);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_init(CUdeviceptr_v1 *arg0, unsigned int arg1) {
+    load_library();
+    return cuMemAlloc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_error(CUdeviceptr_v1 *, unsigned int) {
+    return on_init_failed<CUresult >(286);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemAllocPitch(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_error(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(287);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_init(CUdeviceptr_v1 arg0) {
+    load_library();
+    return cuMemFree(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_error(CUdeviceptr_v1) {
+    return on_init_failed<CUresult >(288);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
+    load_library();
+    return cuMemGetAddressRange(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_error(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1) {
+    return on_init_failed<CUresult >(289);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_init(void **arg0, unsigned int arg1) {
+    load_library();
+    return cuMemAllocHost(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_error(void **, unsigned int) {
+    return on_init_failed<CUresult >(290);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_init(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostGetDevicePointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_error(CUdeviceptr_v1 *, void *, unsigned int) {
+    return on_init_failed<CUresult >(291);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyHtoD(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_error(CUdeviceptr_v1, const void *, unsigned int) {
+    return on_init_failed<CUresult >(292);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyDtoH(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_error(void *, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(293);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyDtoD(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(294);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_init(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyDtoA(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_error(CUarray, unsigned int, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(295);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_init(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyAtoD(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_error(CUdeviceptr_v1, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(296);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyHtoA(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_error(CUarray, unsigned int, const void *, unsigned int) {
+    return on_init_failed<CUresult >(297);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyAtoH(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_error(void *, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(298);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_init(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemcpyAtoA(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_error(CUarray, unsigned int, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(299);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_error(CUarray, unsigned int, const void *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(300);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_error(void *, CUarray, unsigned int, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(301);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_init(const CUDA_MEMCPY2D_v1 *arg0) {
+    load_library();
+    return cuMemcpy2D(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_error(const CUDA_MEMCPY2D_v1 *) {
+    return on_init_failed<CUresult >(302);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_init(const CUDA_MEMCPY2D_v1 *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_error(const CUDA_MEMCPY2D_v1 *) {
+    return on_init_failed<CUresult >(303);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_init(const CUDA_MEMCPY3D_v1 *arg0) {
+    load_library();
+    return cuMemcpy3D(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_error(const CUDA_MEMCPY3D_v1 *) {
+    return on_init_failed<CUresult >(304);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_error(CUdeviceptr_v1, const void *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(305);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_error(void *, CUdeviceptr_v1, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(306);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(307);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_init(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_error(const CUDA_MEMCPY2D_v1 *, CUstream) {
+    return on_init_failed<CUresult >(308);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_init(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_error(const CUDA_MEMCPY3D_v1 *, CUstream) {
+    return on_init_failed<CUresult >(309);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_init(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD8(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_error(CUdeviceptr_v1, unsigned char, unsigned int) {
+    return on_init_failed<CUresult >(310);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_init(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD16(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_error(CUdeviceptr_v1, unsigned short, unsigned int) {
+    return on_init_failed<CUresult >(311);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD32(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_error(CUdeviceptr_v1, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(312);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D8(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_error(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(313);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D16(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_error(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(314);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D32(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_error(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(315);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
+    load_library();
+    return cuArrayCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *) {
+    return on_init_failed<CUresult >(316);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_init(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetDescriptor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_error(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray) {
+    return on_init_failed<CUresult >(317);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
+    load_library();
+    return cuArray3DCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *) {
+    return on_init_failed<CUresult >(318);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_init(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    load_library();
+    return cuArray3DGetDescriptor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_error(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray) {
+    return on_init_failed<CUresult >(319);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_init(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuTexRefSetAddress(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_error(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(320);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuTexRefSetAddress2D(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(321);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_init(CUdeviceptr_v1 *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetAddress(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_error(CUdeviceptr_v1 *, CUtexref) {
+    return on_init_failed<CUresult >(322);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
+    load_library();
+    return cuGraphicsResourceGetMappedPointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_error(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(323);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_error(CUcontext) {
+    return on_init_failed<CUresult >(324);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxPopCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_error(CUcontext *) {
+    return on_init_failed<CUresult >(325);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_init(CUcontext arg0) {
+    load_library();
+    return cuCtxPushCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_error(CUcontext) {
+    return on_init_failed<CUresult >(326);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_init(CUstream arg0) {
+    load_library();
+    return cuStreamDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_error(CUstream) {
+    return on_init_failed<CUresult >(327);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_init(CUevent arg0) {
+    load_library();
+    return cuEventDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_error(CUevent) {
+    return on_init_failed<CUresult >(328);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyHtoD_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_error(CUdeviceptr, const void *, size_t) {
+    return on_init_failed<CUresult >(329);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoH_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_error(void *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(330);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoD_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(331);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyDtoA_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_error(CUarray, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(332);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoD_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_error(CUdeviceptr, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(333);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyHtoA_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_error(CUarray, size_t, const void *, size_t) {
+    return on_init_failed<CUresult >(334);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoH_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_error(void *, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(335);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyAtoA_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_error(CUarray, size_t, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(336);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_error(CUarray, size_t, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(337);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_error(void *, CUarray, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(338);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2D_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(339);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(340);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_init(const CUDA_MEMCPY3D *arg0) {
+    load_library();
+    return cuMemcpy3D_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_error(const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(341);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_error(CUdeviceptr, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(342);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_error(void *, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(343);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(344);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_error(const CUDA_MEMCPY2D *, CUstream) {
+    return on_init_failed<CUresult >(345);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_error(const CUDA_MEMCPY3D *, CUstream) {
+    return on_init_failed<CUresult >(346);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD8_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_error(CUdeviceptr, unsigned char, size_t) {
+    return on_init_failed<CUresult >(347);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD16_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_error(CUdeviceptr, unsigned short, size_t) {
+    return on_init_failed<CUresult >(348);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD32_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_error(CUdeviceptr, unsigned int, size_t) {
+    return on_init_failed<CUresult >(349);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D8_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
+    return on_init_failed<CUresult >(350);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D16_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
+    return on_init_failed<CUresult >(351);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D32_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
+    return on_init_failed<CUresult >(352);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpy(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(353);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(354);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyPeer(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
+    return on_init_failed<CUresult >(355);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemcpyPeerAsync(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
+    return on_init_failed<CUresult >(356);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_init(const CUDA_MEMCPY3D_PEER *arg0) {
+    load_library();
+    return cuMemcpy3DPeer(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_error(const CUDA_MEMCPY3D_PEER *) {
+    return on_init_failed<CUresult >(357);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DPeerAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
+    return on_init_failed<CUresult >(358);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD8Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_error(CUdeviceptr, unsigned char, size_t, CUstream) {
+    return on_init_failed<CUresult >(359);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD16Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_error(CUdeviceptr, unsigned short, size_t, CUstream) {
+    return on_init_failed<CUresult >(360);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD32Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_error(CUdeviceptr, unsigned int, size_t, CUstream) {
+    return on_init_failed<CUresult >(361);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D8Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(362);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D16Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(363);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D32Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(364);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_init(CUstream arg0, int *arg1) {
+    load_library();
+    return cuStreamGetPriority(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_error(CUstream, int *) {
+    return on_init_failed<CUresult >(365);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_init(CUstream arg0, unsigned int *arg1) {
+    load_library();
+    return cuStreamGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_error(CUstream, unsigned int *) {
+    return on_init_failed<CUresult >(366);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(367);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    load_library();
+    return cuStreamWaitEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_error(CUstream, CUevent, unsigned int) {
+    return on_init_failed<CUresult >(368);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAddCallback(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_error(CUstream, CUstreamCallback, void *, unsigned int) {
+    return on_init_failed<CUresult >(369);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(370);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_error(CUstream) {
+    return on_init_failed<CUresult >(371);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_init(CUstream arg0) {
+    load_library();
+    return cuStreamSynchronize(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_error(CUstream) {
+    return on_init_failed<CUresult >(372);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_init(CUevent arg0, CUstream arg1) {
+    load_library();
+    return cuEventRecord(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_error(CUevent, CUstream) {
+    return on_init_failed<CUresult >(373);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    load_library();
+    return cuLaunchKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
+    return on_init_failed<CUresult >(374);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(375);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsMapResources(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(376);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsUnmapResources(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(377);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue32(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(378);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue32(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(379);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(380);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(381);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamBatchMemOp(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
+    return on_init_failed<CUresult >(382);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(383);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(384);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(385);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(386);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_error(CUstream) {
+    return on_init_failed<CUresult >(387);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(388);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(389);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(390);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(391);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(392);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(393);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_init(const char *arg0, const char *arg1, CUoutput_mode arg2) {
+    load_library();
+    return cuProfilerInitialize(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_error(const char *, const char *, CUoutput_mode) {
+    return on_init_failed<CUresult >(394);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStart_init() {
+    load_library();
+    return cuProfilerStart();
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStart_error() {
+    return on_init_failed<CUresult >(395);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStop_init() {
+    load_library();
+    return cuProfilerStop();
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStop_error() {
+    return on_init_failed<CUresult >(396);
+}
+static constexpr size_t NR_FUNC = 397;
+static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
+    (void*)(&cuGetErrorName_init),
+    (void*)(&cuInit_init),
+    (void*)(&cuDriverGetVersion_init),
+    (void*)(&cuDeviceGet_init),
+    (void*)(&cuDeviceGetCount_init),
+    (void*)(&cuDeviceGetName_init),
+    (void*)(&cuDeviceGetUuid_init),
+    (void*)(&cuDeviceTotalMem_v2_init),
+    (void*)(&cuDeviceGetAttribute_init),
+    (void*)(&cuDeviceGetNvSciSyncAttributes_init),
+    (void*)(&cuDeviceGetProperties_init),
+    (void*)(&cuDeviceComputeCapability_init),
+    (void*)(&cuDevicePrimaryCtxRetain_init),
+    (void*)(&cuDevicePrimaryCtxRelease_init),
+    (void*)(&cuDevicePrimaryCtxSetFlags_init),
+    (void*)(&cuDevicePrimaryCtxGetState_init),
+    (void*)(&cuDevicePrimaryCtxReset_init),
+    (void*)(&cuCtxCreate_v2_init),
+    (void*)(&cuCtxDestroy_v2_init),
+    (void*)(&cuCtxPushCurrent_v2_init),
+    (void*)(&cuCtxPopCurrent_v2_init),
+    (void*)(&cuCtxSetCurrent_init),
+    (void*)(&cuCtxGetCurrent_init),
+    (void*)(&cuCtxGetDevice_init),
+    (void*)(&cuCtxGetFlags_init),
+    (void*)(&cuCtxSynchronize_init),
+    (void*)(&cuCtxSetLimit_init),
+    (void*)(&cuCtxGetLimit_init),
+    (void*)(&cuCtxGetCacheConfig_init),
+    (void*)(&cuCtxSetCacheConfig_init),
+    (void*)(&cuCtxGetSharedMemConfig_init),
+    (void*)(&cuCtxSetSharedMemConfig_init),
+    (void*)(&cuCtxGetApiVersion_init),
+    (void*)(&cuCtxGetStreamPriorityRange_init),
+    (void*)(&cuCtxAttach_init),
+    (void*)(&cuCtxDetach_init),
+    (void*)(&cuModuleLoad_init),
+    (void*)(&cuModuleLoadData_init),
+    (void*)(&cuModuleLoadDataEx_init),
+    (void*)(&cuModuleLoadFatBinary_init),
+    (void*)(&cuModuleUnload_init),
+    (void*)(&cuModuleGetFunction_init),
+    (void*)(&cuModuleGetGlobal_v2_init),
+    (void*)(&cuModuleGetTexRef_init),
+    (void*)(&cuModuleGetSurfRef_init),
+    (void*)(&cuLinkCreate_v2_init),
+    (void*)(&cuLinkAddData_v2_init),
+    (void*)(&cuLinkAddFile_v2_init),
+    (void*)(&cuLinkComplete_init),
+    (void*)(&cuLinkDestroy_init),
+    (void*)(&cuMemGetInfo_v2_init),
+    (void*)(&cuMemAlloc_v2_init),
+    (void*)(&cuMemAllocPitch_v2_init),
+    (void*)(&cuMemFree_v2_init),
+    (void*)(&cuMemGetAddressRange_v2_init),
+    (void*)(&cuMemAllocHost_v2_init),
+    (void*)(&cuMemFreeHost_init),
+    (void*)(&cuMemHostAlloc_init),
+    (void*)(&cuMemHostGetDevicePointer_v2_init),
+    (void*)(&cuMemHostGetFlags_init),
+    (void*)(&cuMemAllocManaged_init),
+    (void*)(&cuDeviceGetByPCIBusId_init),
+    (void*)(&cuDeviceGetPCIBusId_init),
+    (void*)(&cuIpcGetEventHandle_init),
+    (void*)(&cuIpcOpenEventHandle_init),
+    (void*)(&cuIpcGetMemHandle_init),
+    (void*)(&cuIpcOpenMemHandle_init),
+    (void*)(&cuIpcCloseMemHandle_init),
+    (void*)(&cuMemHostRegister_v2_init),
+    (void*)(&cuMemHostUnregister_init),
+    (void*)(&cuMemcpy_ptds_init),
+    (void*)(&cuMemcpyPeer_ptds_init),
+    (void*)(&cuMemcpyHtoD_v2_ptds_init),
+    (void*)(&cuMemcpyDtoH_v2_ptds_init),
+    (void*)(&cuMemcpyDtoD_v2_ptds_init),
+    (void*)(&cuMemcpyDtoA_v2_ptds_init),
+    (void*)(&cuMemcpyAtoD_v2_ptds_init),
+    (void*)(&cuMemcpyHtoA_v2_ptds_init),
+    (void*)(&cuMemcpyAtoH_v2_ptds_init),
+    (void*)(&cuMemcpyAtoA_v2_ptds_init),
+    (void*)(&cuMemcpy2D_v2_ptds_init),
+    (void*)(&cuMemcpy2DUnaligned_v2_ptds_init),
+    (void*)(&cuMemcpy3D_v2_ptds_init),
+    (void*)(&cuMemcpy3DPeer_ptds_init),
+    (void*)(&cuMemcpyAsync_ptsz_init),
+    (void*)(&cuMemcpyPeerAsync_ptsz_init),
+    (void*)(&cuMemcpyHtoDAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyDtoHAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyDtoDAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyHtoAAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyAtoHAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy2DAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy3DAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy3DPeerAsync_ptsz_init),
+    (void*)(&cuMemsetD8_v2_ptds_init),
+    (void*)(&cuMemsetD16_v2_ptds_init),
+    (void*)(&cuMemsetD32_v2_ptds_init),
+    (void*)(&cuMemsetD2D8_v2_ptds_init),
+    (void*)(&cuMemsetD2D16_v2_ptds_init),
+    (void*)(&cuMemsetD2D32_v2_ptds_init),
+    (void*)(&cuMemsetD8Async_ptsz_init),
+    (void*)(&cuMemsetD16Async_ptsz_init),
+    (void*)(&cuMemsetD32Async_ptsz_init),
+    (void*)(&cuMemsetD2D8Async_ptsz_init),
+    (void*)(&cuMemsetD2D16Async_ptsz_init),
+    (void*)(&cuMemsetD2D32Async_ptsz_init),
+    (void*)(&cuArrayCreate_v2_init),
+    (void*)(&cuArrayGetDescriptor_v2_init),
+    (void*)(&cuArrayDestroy_init),
+    (void*)(&cuArray3DCreate_v2_init),
+    (void*)(&cuArray3DGetDescriptor_v2_init),
+    (void*)(&cuMipmappedArrayCreate_init),
+    (void*)(&cuMipmappedArrayGetLevel_init),
+    (void*)(&cuMipmappedArrayDestroy_init),
+    (void*)(&cuMemAddressReserve_init),
+    (void*)(&cuMemAddressFree_init),
+    (void*)(&cuMemCreate_init),
+    (void*)(&cuMemRelease_init),
+    (void*)(&cuMemMap_init),
+    (void*)(&cuMemUnmap_init),
+    (void*)(&cuMemSetAccess_init),
+    (void*)(&cuMemGetAccess_init),
+    (void*)(&cuMemExportToShareableHandle_init),
+    (void*)(&cuMemImportFromShareableHandle_init),
+    (void*)(&cuMemGetAllocationGranularity_init),
+    (void*)(&cuMemGetAllocationPropertiesFromHandle_init),
+    (void*)(&cuPointerGetAttribute_init),
+    (void*)(&cuMemPrefetchAsync_ptsz_init),
+    (void*)(&cuMemAdvise_init),
+    (void*)(&cuMemRangeGetAttribute_init),
+    (void*)(&cuMemRangeGetAttributes_init),
+    (void*)(&cuPointerSetAttribute_init),
+    (void*)(&cuPointerGetAttributes_init),
+    (void*)(&cuStreamCreate_init),
+    (void*)(&cuStreamCreateWithPriority_init),
+    (void*)(&cuStreamGetPriority_ptsz_init),
+    (void*)(&cuStreamGetFlags_ptsz_init),
+    (void*)(&cuStreamGetCtx_ptsz_init),
+    (void*)(&cuStreamWaitEvent_ptsz_init),
+    (void*)(&cuStreamAddCallback_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_init),
+    (void*)(&cuThreadExchangeStreamCaptureMode_init),
+    (void*)(&cuStreamEndCapture_ptsz_init),
+    (void*)(&cuStreamIsCapturing_ptsz_init),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_init),
+    (void*)(&cuStreamAttachMemAsync_ptsz_init),
+    (void*)(&cuStreamQuery_ptsz_init),
+    (void*)(&cuStreamSynchronize_ptsz_init),
+    (void*)(&cuStreamDestroy_v2_init),
+    (void*)(&cuEventCreate_init),
+    (void*)(&cuEventRecord_ptsz_init),
+    (void*)(&cuEventQuery_init),
+    (void*)(&cuEventSynchronize_init),
+    (void*)(&cuEventDestroy_v2_init),
+    (void*)(&cuEventElapsedTime_init),
+    (void*)(&cuImportExternalMemory_init),
+    (void*)(&cuExternalMemoryGetMappedBuffer_init),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_init),
+    (void*)(&cuDestroyExternalMemory_init),
+    (void*)(&cuImportExternalSemaphore_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuDestroyExternalSemaphore_init),
+    (void*)(&cuStreamWaitValue32_ptsz_init),
+    (void*)(&cuStreamWaitValue64_ptsz_init),
+    (void*)(&cuStreamWriteValue32_ptsz_init),
+    (void*)(&cuStreamWriteValue64_ptsz_init),
+    (void*)(&cuStreamBatchMemOp_ptsz_init),
+    (void*)(&cuFuncGetAttribute_init),
+    (void*)(&cuFuncSetAttribute_init),
+    (void*)(&cuFuncSetCacheConfig_init),
+    (void*)(&cuFuncSetSharedMemConfig_init),
+    (void*)(&cuLaunchKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_init),
+    (void*)(&cuLaunchHostFunc_ptsz_init),
+    (void*)(&cuFuncSetBlockShape_init),
+    (void*)(&cuFuncSetSharedSize_init),
+    (void*)(&cuParamSetSize_init),
+    (void*)(&cuParamSeti_init),
+    (void*)(&cuParamSetf_init),
+    (void*)(&cuParamSetv_init),
+    (void*)(&cuLaunch_init),
+    (void*)(&cuLaunchGrid_init),
+    (void*)(&cuLaunchGridAsync_init),
+    (void*)(&cuParamSetTexRef_init),
+    (void*)(&cuGraphCreate_init),
+    (void*)(&cuGraphAddKernelNode_init),
+    (void*)(&cuGraphKernelNodeGetParams_init),
+    (void*)(&cuGraphKernelNodeSetParams_init),
+    (void*)(&cuGraphAddMemcpyNode_init),
+    (void*)(&cuGraphMemcpyNodeGetParams_init),
+    (void*)(&cuGraphMemcpyNodeSetParams_init),
+    (void*)(&cuGraphAddMemsetNode_init),
+    (void*)(&cuGraphMemsetNodeGetParams_init),
+    (void*)(&cuGraphMemsetNodeSetParams_init),
+    (void*)(&cuGraphAddHostNode_init),
+    (void*)(&cuGraphHostNodeGetParams_init),
+    (void*)(&cuGraphHostNodeSetParams_init),
+    (void*)(&cuGraphAddChildGraphNode_init),
+    (void*)(&cuGraphChildGraphNodeGetGraph_init),
+    (void*)(&cuGraphAddEmptyNode_init),
+    (void*)(&cuGraphClone_init),
+    (void*)(&cuGraphNodeFindInClone_init),
+    (void*)(&cuGraphNodeGetType_init),
+    (void*)(&cuGraphGetNodes_init),
+    (void*)(&cuGraphGetRootNodes_init),
+    (void*)(&cuGraphGetEdges_init),
+    (void*)(&cuGraphNodeGetDependencies_init),
+    (void*)(&cuGraphNodeGetDependentNodes_init),
+    (void*)(&cuGraphAddDependencies_init),
+    (void*)(&cuGraphRemoveDependencies_init),
+    (void*)(&cuGraphDestroyNode_init),
+    (void*)(&cuGraphInstantiate_init),
+    (void*)(&cuGraphExecKernelNodeSetParams_init),
+    (void*)(&cuGraphExecMemcpyNodeSetParams_init),
+    (void*)(&cuGraphExecMemsetNodeSetParams_init),
+    (void*)(&cuGraphExecHostNodeSetParams_init),
+    (void*)(&cuGraphLaunch_ptsz_init),
+    (void*)(&cuGraphExecDestroy_init),
+    (void*)(&cuGraphDestroy_init),
+    (void*)(&cuGraphExecUpdate_init),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_init),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init),
+    (void*)(&cuOccupancyMaxPotentialBlockSize_init),
+    (void*)(&cuOccupancyMaxPotentialBlockSizeWithFlags_init),
+    (void*)(&cuTexRefSetArray_init),
+    (void*)(&cuTexRefSetMipmappedArray_init),
+    (void*)(&cuTexRefSetAddress_v2_init),
+    (void*)(&cuTexRefSetAddress2D_v3_init),
+    (void*)(&cuTexRefSetFormat_init),
+    (void*)(&cuTexRefSetAddressMode_init),
+    (void*)(&cuTexRefSetFilterMode_init),
+    (void*)(&cuTexRefSetMipmapFilterMode_init),
+    (void*)(&cuTexRefSetMipmapLevelBias_init),
+    (void*)(&cuTexRefSetMipmapLevelClamp_init),
+    (void*)(&cuTexRefSetMaxAnisotropy_init),
+    (void*)(&cuTexRefSetBorderColor_init),
+    (void*)(&cuTexRefSetFlags_init),
+    (void*)(&cuTexRefGetAddress_v2_init),
+    (void*)(&cuTexRefGetArray_init),
+    (void*)(&cuTexRefGetMipmappedArray_init),
+    (void*)(&cuTexRefGetAddressMode_init),
+    (void*)(&cuTexRefGetFilterMode_init),
+    (void*)(&cuTexRefGetFormat_init),
+    (void*)(&cuTexRefGetMipmapFilterMode_init),
+    (void*)(&cuTexRefGetMipmapLevelBias_init),
+    (void*)(&cuTexRefGetMipmapLevelClamp_init),
+    (void*)(&cuTexRefGetMaxAnisotropy_init),
+    (void*)(&cuTexRefGetBorderColor_init),
+    (void*)(&cuTexRefGetFlags_init),
+    (void*)(&cuTexRefCreate_init),
+    (void*)(&cuTexRefDestroy_init),
+    (void*)(&cuSurfRefSetArray_init),
+    (void*)(&cuSurfRefGetArray_init),
+    (void*)(&cuTexObjectCreate_init),
+    (void*)(&cuTexObjectDestroy_init),
+    (void*)(&cuTexObjectGetResourceDesc_init),
+    (void*)(&cuTexObjectGetTextureDesc_init),
+    (void*)(&cuTexObjectGetResourceViewDesc_init),
+    (void*)(&cuSurfObjectCreate_init),
+    (void*)(&cuSurfObjectDestroy_init),
+    (void*)(&cuSurfObjectGetResourceDesc_init),
+    (void*)(&cuDeviceCanAccessPeer_init),
+    (void*)(&cuCtxEnablePeerAccess_init),
+    (void*)(&cuCtxDisablePeerAccess_init),
+    (void*)(&cuDeviceGetP2PAttribute_init),
+    (void*)(&cuGraphicsUnregisterResource_init),
+    (void*)(&cuGraphicsSubResourceGetMappedArray_init),
+    (void*)(&cuGraphicsResourceGetMappedMipmappedArray_init),
+    (void*)(&cuGraphicsResourceGetMappedPointer_v2_init),
+    (void*)(&cuGraphicsResourceSetMapFlags_v2_init),
+    (void*)(&cuGraphicsMapResources_ptsz_init),
+    (void*)(&cuGraphicsUnmapResources_ptsz_init),
+    (void*)(&cuGetExportTable_init),
+    (void*)(&cuMemHostRegister_init),
+    (void*)(&cuGraphicsResourceSetMapFlags_init),
+    (void*)(&cuLinkCreate_init),
+    (void*)(&cuLinkAddData_init),
+    (void*)(&cuLinkAddFile_init),
+    (void*)(&cuTexRefSetAddress2D_v2_init),
+    (void*)(&cuDeviceTotalMem_init),
+    (void*)(&cuCtxCreate_init),
+    (void*)(&cuModuleGetGlobal_init),
+    (void*)(&cuMemGetInfo_init),
+    (void*)(&cuMemAlloc_init),
+    (void*)(&cuMemAllocPitch_init),
+    (void*)(&cuMemFree_init),
+    (void*)(&cuMemGetAddressRange_init),
+    (void*)(&cuMemAllocHost_init),
+    (void*)(&cuMemHostGetDevicePointer_init),
+    (void*)(&cuMemcpyHtoD_init),
+    (void*)(&cuMemcpyDtoH_init),
+    (void*)(&cuMemcpyDtoD_init),
+    (void*)(&cuMemcpyDtoA_init),
+    (void*)(&cuMemcpyAtoD_init),
+    (void*)(&cuMemcpyHtoA_init),
+    (void*)(&cuMemcpyAtoH_init),
+    (void*)(&cuMemcpyAtoA_init),
+    (void*)(&cuMemcpyHtoAAsync_init),
+    (void*)(&cuMemcpyAtoHAsync_init),
+    (void*)(&cuMemcpy2D_init),
+    (void*)(&cuMemcpy2DUnaligned_init),
+    (void*)(&cuMemcpy3D_init),
+    (void*)(&cuMemcpyHtoDAsync_init),
+    (void*)(&cuMemcpyDtoHAsync_init),
+    (void*)(&cuMemcpyDtoDAsync_init),
+    (void*)(&cuMemcpy2DAsync_init),
+    (void*)(&cuMemcpy3DAsync_init),
+    (void*)(&cuMemsetD8_init),
+    (void*)(&cuMemsetD16_init),
+    (void*)(&cuMemsetD32_init),
+    (void*)(&cuMemsetD2D8_init),
+    (void*)(&cuMemsetD2D16_init),
+    (void*)(&cuMemsetD2D32_init),
+    (void*)(&cuArrayCreate_init),
+    (void*)(&cuArrayGetDescriptor_init),
+    (void*)(&cuArray3DCreate_init),
+    (void*)(&cuArray3DGetDescriptor_init),
+    (void*)(&cuTexRefSetAddress_init),
+    (void*)(&cuTexRefSetAddress2D_init),
+    (void*)(&cuTexRefGetAddress_init),
+    (void*)(&cuGraphicsResourceGetMappedPointer_init),
+    (void*)(&cuCtxDestroy_init),
+    (void*)(&cuCtxPopCurrent_init),
+    (void*)(&cuCtxPushCurrent_init),
+    (void*)(&cuStreamDestroy_init),
+    (void*)(&cuEventDestroy_init),
+    (void*)(&cuMemcpyHtoD_v2_init),
+    (void*)(&cuMemcpyDtoH_v2_init),
+    (void*)(&cuMemcpyDtoD_v2_init),
+    (void*)(&cuMemcpyDtoA_v2_init),
+    (void*)(&cuMemcpyAtoD_v2_init),
+    (void*)(&cuMemcpyHtoA_v2_init),
+    (void*)(&cuMemcpyAtoH_v2_init),
+    (void*)(&cuMemcpyAtoA_v2_init),
+    (void*)(&cuMemcpyHtoAAsync_v2_init),
+    (void*)(&cuMemcpyAtoHAsync_v2_init),
+    (void*)(&cuMemcpy2D_v2_init),
+    (void*)(&cuMemcpy2DUnaligned_v2_init),
+    (void*)(&cuMemcpy3D_v2_init),
+    (void*)(&cuMemcpyHtoDAsync_v2_init),
+    (void*)(&cuMemcpyDtoHAsync_v2_init),
+    (void*)(&cuMemcpyDtoDAsync_v2_init),
+    (void*)(&cuMemcpy2DAsync_v2_init),
+    (void*)(&cuMemcpy3DAsync_v2_init),
+    (void*)(&cuMemsetD8_v2_init),
+    (void*)(&cuMemsetD16_v2_init),
+    (void*)(&cuMemsetD32_v2_init),
+    (void*)(&cuMemsetD2D8_v2_init),
+    (void*)(&cuMemsetD2D16_v2_init),
+    (void*)(&cuMemsetD2D32_v2_init),
+    (void*)(&cuMemcpy_init),
+    (void*)(&cuMemcpyAsync_init),
+    (void*)(&cuMemcpyPeer_init),
+    (void*)(&cuMemcpyPeerAsync_init),
+    (void*)(&cuMemcpy3DPeer_init),
+    (void*)(&cuMemcpy3DPeerAsync_init),
+    (void*)(&cuMemsetD8Async_init),
+    (void*)(&cuMemsetD16Async_init),
+    (void*)(&cuMemsetD32Async_init),
+    (void*)(&cuMemsetD2D8Async_init),
+    (void*)(&cuMemsetD2D16Async_init),
+    (void*)(&cuMemsetD2D32Async_init),
+    (void*)(&cuStreamGetPriority_init),
+    (void*)(&cuStreamGetFlags_init),
+    (void*)(&cuStreamGetCtx_init),
+    (void*)(&cuStreamWaitEvent_init),
+    (void*)(&cuStreamAddCallback_init),
+    (void*)(&cuStreamAttachMemAsync_init),
+    (void*)(&cuStreamQuery_init),
+    (void*)(&cuStreamSynchronize_init),
+    (void*)(&cuEventRecord_init),
+    (void*)(&cuLaunchKernel_init),
+    (void*)(&cuLaunchHostFunc_init),
+    (void*)(&cuGraphicsMapResources_init),
+    (void*)(&cuGraphicsUnmapResources_init),
+    (void*)(&cuStreamWriteValue32_init),
+    (void*)(&cuStreamWaitValue32_init),
+    (void*)(&cuStreamWriteValue64_init),
+    (void*)(&cuStreamWaitValue64_init),
+    (void*)(&cuStreamBatchMemOp_init),
+    (void*)(&cuMemPrefetchAsync_init),
+    (void*)(&cuLaunchCooperativeKernel_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_init),
+    (void*)(&cuStreamBeginCapture_init),
+    (void*)(&cuStreamBeginCapture_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_init),
+    (void*)(&cuStreamEndCapture_init),
+    (void*)(&cuStreamIsCapturing_init),
+    (void*)(&cuStreamGetCaptureInfo_init),
+    (void*)(&cuGraphLaunch_init),
+    (void*)(&cuProfilerInitialize_init),
+    (void*)(&cuProfilerStart_init),
+    (void*)(&cuProfilerStop_init)};
+static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
+    (void*)(&cuGetErrorName_error),
+    (void*)(&cuInit_error),
+    (void*)(&cuDriverGetVersion_error),
+    (void*)(&cuDeviceGet_error),
+    (void*)(&cuDeviceGetCount_error),
+    (void*)(&cuDeviceGetName_error),
+    (void*)(&cuDeviceGetUuid_error),
+    (void*)(&cuDeviceTotalMem_v2_error),
+    (void*)(&cuDeviceGetAttribute_error),
+    (void*)(&cuDeviceGetNvSciSyncAttributes_error),
+    (void*)(&cuDeviceGetProperties_error),
+    (void*)(&cuDeviceComputeCapability_error),
+    (void*)(&cuDevicePrimaryCtxRetain_error),
+    (void*)(&cuDevicePrimaryCtxRelease_error),
+    (void*)(&cuDevicePrimaryCtxSetFlags_error),
+    (void*)(&cuDevicePrimaryCtxGetState_error),
+    (void*)(&cuDevicePrimaryCtxReset_error),
+    (void*)(&cuCtxCreate_v2_error),
+    (void*)(&cuCtxDestroy_v2_error),
+    (void*)(&cuCtxPushCurrent_v2_error),
+    (void*)(&cuCtxPopCurrent_v2_error),
+    (void*)(&cuCtxSetCurrent_error),
+    (void*)(&cuCtxGetCurrent_error),
+    (void*)(&cuCtxGetDevice_error),
+    (void*)(&cuCtxGetFlags_error),
+    (void*)(&cuCtxSynchronize_error),
+    (void*)(&cuCtxSetLimit_error),
+    (void*)(&cuCtxGetLimit_error),
+    (void*)(&cuCtxGetCacheConfig_error),
+    (void*)(&cuCtxSetCacheConfig_error),
+    (void*)(&cuCtxGetSharedMemConfig_error),
+    (void*)(&cuCtxSetSharedMemConfig_error),
+    (void*)(&cuCtxGetApiVersion_error),
+    (void*)(&cuCtxGetStreamPriorityRange_error),
+    (void*)(&cuCtxAttach_error),
+    (void*)(&cuCtxDetach_error),
+    (void*)(&cuModuleLoad_error),
+    (void*)(&cuModuleLoadData_error),
+    (void*)(&cuModuleLoadDataEx_error),
+    (void*)(&cuModuleLoadFatBinary_error),
+    (void*)(&cuModuleUnload_error),
+    (void*)(&cuModuleGetFunction_error),
+    (void*)(&cuModuleGetGlobal_v2_error),
+    (void*)(&cuModuleGetTexRef_error),
+    (void*)(&cuModuleGetSurfRef_error),
+    (void*)(&cuLinkCreate_v2_error),
+    (void*)(&cuLinkAddData_v2_error),
+    (void*)(&cuLinkAddFile_v2_error),
+    (void*)(&cuLinkComplete_error),
+    (void*)(&cuLinkDestroy_error),
+    (void*)(&cuMemGetInfo_v2_error),
+    (void*)(&cuMemAlloc_v2_error),
+    (void*)(&cuMemAllocPitch_v2_error),
+    (void*)(&cuMemFree_v2_error),
+    (void*)(&cuMemGetAddressRange_v2_error),
+    (void*)(&cuMemAllocHost_v2_error),
+    (void*)(&cuMemFreeHost_error),
+    (void*)(&cuMemHostAlloc_error),
+    (void*)(&cuMemHostGetDevicePointer_v2_error),
+    (void*)(&cuMemHostGetFlags_error),
+    (void*)(&cuMemAllocManaged_error),
+    (void*)(&cuDeviceGetByPCIBusId_error),
+    (void*)(&cuDeviceGetPCIBusId_error),
+    (void*)(&cuIpcGetEventHandle_error),
+    (void*)(&cuIpcOpenEventHandle_error),
+    (void*)(&cuIpcGetMemHandle_error),
+    (void*)(&cuIpcOpenMemHandle_error),
+    (void*)(&cuIpcCloseMemHandle_error),
+    (void*)(&cuMemHostRegister_v2_error),
+    (void*)(&cuMemHostUnregister_error),
+    (void*)(&cuMemcpy_ptds_error),
+    (void*)(&cuMemcpyPeer_ptds_error),
+    (void*)(&cuMemcpyHtoD_v2_ptds_error),
+    (void*)(&cuMemcpyDtoH_v2_ptds_error),
+    (void*)(&cuMemcpyDtoD_v2_ptds_error),
+    (void*)(&cuMemcpyDtoA_v2_ptds_error),
+    (void*)(&cuMemcpyAtoD_v2_ptds_error),
+    (void*)(&cuMemcpyHtoA_v2_ptds_error),
+    (void*)(&cuMemcpyAtoH_v2_ptds_error),
+    (void*)(&cuMemcpyAtoA_v2_ptds_error),
+    (void*)(&cuMemcpy2D_v2_ptds_error),
+    (void*)(&cuMemcpy2DUnaligned_v2_ptds_error),
+    (void*)(&cuMemcpy3D_v2_ptds_error),
+    (void*)(&cuMemcpy3DPeer_ptds_error),
+    (void*)(&cuMemcpyAsync_ptsz_error),
+    (void*)(&cuMemcpyPeerAsync_ptsz_error),
+    (void*)(&cuMemcpyHtoDAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyDtoHAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyDtoDAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyHtoAAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyAtoHAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy2DAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy3DAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy3DPeerAsync_ptsz_error),
+    (void*)(&cuMemsetD8_v2_ptds_error),
+    (void*)(&cuMemsetD16_v2_ptds_error),
+    (void*)(&cuMemsetD32_v2_ptds_error),
+    (void*)(&cuMemsetD2D8_v2_ptds_error),
+    (void*)(&cuMemsetD2D16_v2_ptds_error),
+    (void*)(&cuMemsetD2D32_v2_ptds_error),
+    (void*)(&cuMemsetD8Async_ptsz_error),
+    (void*)(&cuMemsetD16Async_ptsz_error),
+    (void*)(&cuMemsetD32Async_ptsz_error),
+    (void*)(&cuMemsetD2D8Async_ptsz_error),
+    (void*)(&cuMemsetD2D16Async_ptsz_error),
+    (void*)(&cuMemsetD2D32Async_ptsz_error),
+    (void*)(&cuArrayCreate_v2_error),
+    (void*)(&cuArrayGetDescriptor_v2_error),
+    (void*)(&cuArrayDestroy_error),
+    (void*)(&cuArray3DCreate_v2_error),
+    (void*)(&cuArray3DGetDescriptor_v2_error),
+    (void*)(&cuMipmappedArrayCreate_error),
+    (void*)(&cuMipmappedArrayGetLevel_error),
+    (void*)(&cuMipmappedArrayDestroy_error),
+    (void*)(&cuMemAddressReserve_error),
+    (void*)(&cuMemAddressFree_error),
+    (void*)(&cuMemCreate_error),
+    (void*)(&cuMemRelease_error),
+    (void*)(&cuMemMap_error),
+    (void*)(&cuMemUnmap_error),
+    (void*)(&cuMemSetAccess_error),
+    (void*)(&cuMemGetAccess_error),
+    (void*)(&cuMemExportToShareableHandle_error),
+    (void*)(&cuMemImportFromShareableHandle_error),
+    (void*)(&cuMemGetAllocationGranularity_error),
+    (void*)(&cuMemGetAllocationPropertiesFromHandle_error),
+    (void*)(&cuPointerGetAttribute_error),
+    (void*)(&cuMemPrefetchAsync_ptsz_error),
+    (void*)(&cuMemAdvise_error),
+    (void*)(&cuMemRangeGetAttribute_error),
+    (void*)(&cuMemRangeGetAttributes_error),
+    (void*)(&cuPointerSetAttribute_error),
+    (void*)(&cuPointerGetAttributes_error),
+    (void*)(&cuStreamCreate_error),
+    (void*)(&cuStreamCreateWithPriority_error),
+    (void*)(&cuStreamGetPriority_ptsz_error),
+    (void*)(&cuStreamGetFlags_ptsz_error),
+    (void*)(&cuStreamGetCtx_ptsz_error),
+    (void*)(&cuStreamWaitEvent_ptsz_error),
+    (void*)(&cuStreamAddCallback_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_error),
+    (void*)(&cuThreadExchangeStreamCaptureMode_error),
+    (void*)(&cuStreamEndCapture_ptsz_error),
+    (void*)(&cuStreamIsCapturing_ptsz_error),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_error),
+    (void*)(&cuStreamAttachMemAsync_ptsz_error),
+    (void*)(&cuStreamQuery_ptsz_error),
+    (void*)(&cuStreamSynchronize_ptsz_error),
+    (void*)(&cuStreamDestroy_v2_error),
+    (void*)(&cuEventCreate_error),
+    (void*)(&cuEventRecord_ptsz_error),
+    (void*)(&cuEventQuery_error),
+    (void*)(&cuEventSynchronize_error),
+    (void*)(&cuEventDestroy_v2_error),
+    (void*)(&cuEventElapsedTime_error),
+    (void*)(&cuImportExternalMemory_error),
+    (void*)(&cuExternalMemoryGetMappedBuffer_error),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_error),
+    (void*)(&cuDestroyExternalMemory_error),
+    (void*)(&cuImportExternalSemaphore_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuDestroyExternalSemaphore_error),
+    (void*)(&cuStreamWaitValue32_ptsz_error),
+    (void*)(&cuStreamWaitValue64_ptsz_error),
+    (void*)(&cuStreamWriteValue32_ptsz_error),
+    (void*)(&cuStreamWriteValue64_ptsz_error),
+    (void*)(&cuStreamBatchMemOp_ptsz_error),
+    (void*)(&cuFuncGetAttribute_error),
+    (void*)(&cuFuncSetAttribute_error),
+    (void*)(&cuFuncSetCacheConfig_error),
+    (void*)(&cuFuncSetSharedMemConfig_error),
+    (void*)(&cuLaunchKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_error),
+    (void*)(&cuLaunchHostFunc_ptsz_error),
+    (void*)(&cuFuncSetBlockShape_error),
+    (void*)(&cuFuncSetSharedSize_error),
+    (void*)(&cuParamSetSize_error),
+    (void*)(&cuParamSeti_error),
+    (void*)(&cuParamSetf_error),
+    (void*)(&cuParamSetv_error),
+    (void*)(&cuLaunch_error),
+    (void*)(&cuLaunchGrid_error),
+    (void*)(&cuLaunchGridAsync_error),
+    (void*)(&cuParamSetTexRef_error),
+    (void*)(&cuGraphCreate_error),
+    (void*)(&cuGraphAddKernelNode_error),
+    (void*)(&cuGraphKernelNodeGetParams_error),
+    (void*)(&cuGraphKernelNodeSetParams_error),
+    (void*)(&cuGraphAddMemcpyNode_error),
+    (void*)(&cuGraphMemcpyNodeGetParams_error),
+    (void*)(&cuGraphMemcpyNodeSetParams_error),
+    (void*)(&cuGraphAddMemsetNode_error),
+    (void*)(&cuGraphMemsetNodeGetParams_error),
+    (void*)(&cuGraphMemsetNodeSetParams_error),
+    (void*)(&cuGraphAddHostNode_error),
+    (void*)(&cuGraphHostNodeGetParams_error),
+    (void*)(&cuGraphHostNodeSetParams_error),
+    (void*)(&cuGraphAddChildGraphNode_error),
+    (void*)(&cuGraphChildGraphNodeGetGraph_error),
+    (void*)(&cuGraphAddEmptyNode_error),
+    (void*)(&cuGraphClone_error),
+    (void*)(&cuGraphNodeFindInClone_error),
+    (void*)(&cuGraphNodeGetType_error),
+    (void*)(&cuGraphGetNodes_error),
+    (void*)(&cuGraphGetRootNodes_error),
+    (void*)(&cuGraphGetEdges_error),
+    (void*)(&cuGraphNodeGetDependencies_error),
+    (void*)(&cuGraphNodeGetDependentNodes_error),
+    (void*)(&cuGraphAddDependencies_error),
+    (void*)(&cuGraphRemoveDependencies_error),
+    (void*)(&cuGraphDestroyNode_error),
+    (void*)(&cuGraphInstantiate_error),
+    (void*)(&cuGraphExecKernelNodeSetParams_error),
+    (void*)(&cuGraphExecMemcpyNodeSetParams_error),
+    (void*)(&cuGraphExecMemsetNodeSetParams_error),
+    (void*)(&cuGraphExecHostNodeSetParams_error),
+    (void*)(&cuGraphLaunch_ptsz_error),
+    (void*)(&cuGraphExecDestroy_error),
+    (void*)(&cuGraphDestroy_error),
+    (void*)(&cuGraphExecUpdate_error),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_error),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error),
+    (void*)(&cuOccupancyMaxPotentialBlockSize_error),
+    (void*)(&cuOccupancyMaxPotentialBlockSizeWithFlags_error),
+    (void*)(&cuTexRefSetArray_error),
+    (void*)(&cuTexRefSetMipmappedArray_error),
+    (void*)(&cuTexRefSetAddress_v2_error),
+    (void*)(&cuTexRefSetAddress2D_v3_error),
+    (void*)(&cuTexRefSetFormat_error),
+    (void*)(&cuTexRefSetAddressMode_error),
+    (void*)(&cuTexRefSetFilterMode_error),
+    (void*)(&cuTexRefSetMipmapFilterMode_error),
+    (void*)(&cuTexRefSetMipmapLevelBias_error),
+    (void*)(&cuTexRefSetMipmapLevelClamp_error),
+    (void*)(&cuTexRefSetMaxAnisotropy_error),
+    (void*)(&cuTexRefSetBorderColor_error),
+    (void*)(&cuTexRefSetFlags_error),
+    (void*)(&cuTexRefGetAddress_v2_error),
+    (void*)(&cuTexRefGetArray_error),
+    (void*)(&cuTexRefGetMipmappedArray_error),
+    (void*)(&cuTexRefGetAddressMode_error),
+    (void*)(&cuTexRefGetFilterMode_error),
+    (void*)(&cuTexRefGetFormat_error),
+    (void*)(&cuTexRefGetMipmapFilterMode_error),
+    (void*)(&cuTexRefGetMipmapLevelBias_error),
+    (void*)(&cuTexRefGetMipmapLevelClamp_error),
+    (void*)(&cuTexRefGetMaxAnisotropy_error),
+    (void*)(&cuTexRefGetBorderColor_error),
+    (void*)(&cuTexRefGetFlags_error),
+    (void*)(&cuTexRefCreate_error),
+    (void*)(&cuTexRefDestroy_error),
+    (void*)(&cuSurfRefSetArray_error),
+    (void*)(&cuSurfRefGetArray_error),
+    (void*)(&cuTexObjectCreate_error),
+    (void*)(&cuTexObjectDestroy_error),
+    (void*)(&cuTexObjectGetResourceDesc_error),
+    (void*)(&cuTexObjectGetTextureDesc_error),
+    (void*)(&cuTexObjectGetResourceViewDesc_error),
+    (void*)(&cuSurfObjectCreate_error),
+    (void*)(&cuSurfObjectDestroy_error),
+    (void*)(&cuSurfObjectGetResourceDesc_error),
+    (void*)(&cuDeviceCanAccessPeer_error),
+    (void*)(&cuCtxEnablePeerAccess_error),
+    (void*)(&cuCtxDisablePeerAccess_error),
+    (void*)(&cuDeviceGetP2PAttribute_error),
+    (void*)(&cuGraphicsUnregisterResource_error),
+    (void*)(&cuGraphicsSubResourceGetMappedArray_error),
+    (void*)(&cuGraphicsResourceGetMappedMipmappedArray_error),
+    (void*)(&cuGraphicsResourceGetMappedPointer_v2_error),
+    (void*)(&cuGraphicsResourceSetMapFlags_v2_error),
+    (void*)(&cuGraphicsMapResources_ptsz_error),
+    (void*)(&cuGraphicsUnmapResources_ptsz_error),
+    (void*)(&cuGetExportTable_error),
+    (void*)(&cuMemHostRegister_error),
+    (void*)(&cuGraphicsResourceSetMapFlags_error),
+    (void*)(&cuLinkCreate_error),
+    (void*)(&cuLinkAddData_error),
+    (void*)(&cuLinkAddFile_error),
+    (void*)(&cuTexRefSetAddress2D_v2_error),
+    (void*)(&cuDeviceTotalMem_error),
+    (void*)(&cuCtxCreate_error),
+    (void*)(&cuModuleGetGlobal_error),
+    (void*)(&cuMemGetInfo_error),
+    (void*)(&cuMemAlloc_error),
+    (void*)(&cuMemAllocPitch_error),
+    (void*)(&cuMemFree_error),
+    (void*)(&cuMemGetAddressRange_error),
+    (void*)(&cuMemAllocHost_error),
+    (void*)(&cuMemHostGetDevicePointer_error),
+    (void*)(&cuMemcpyHtoD_error),
+    (void*)(&cuMemcpyDtoH_error),
+    (void*)(&cuMemcpyDtoD_error),
+    (void*)(&cuMemcpyDtoA_error),
+    (void*)(&cuMemcpyAtoD_error),
+    (void*)(&cuMemcpyHtoA_error),
+    (void*)(&cuMemcpyAtoH_error),
+    (void*)(&cuMemcpyAtoA_error),
+    (void*)(&cuMemcpyHtoAAsync_error),
+    (void*)(&cuMemcpyAtoHAsync_error),
+    (void*)(&cuMemcpy2D_error),
+    (void*)(&cuMemcpy2DUnaligned_error),
+    (void*)(&cuMemcpy3D_error),
+    (void*)(&cuMemcpyHtoDAsync_error),
+    (void*)(&cuMemcpyDtoHAsync_error),
+    (void*)(&cuMemcpyDtoDAsync_error),
+    (void*)(&cuMemcpy2DAsync_error),
+    (void*)(&cuMemcpy3DAsync_error),
+    (void*)(&cuMemsetD8_error),
+    (void*)(&cuMemsetD16_error),
+    (void*)(&cuMemsetD32_error),
+    (void*)(&cuMemsetD2D8_error),
+    (void*)(&cuMemsetD2D16_error),
+    (void*)(&cuMemsetD2D32_error),
+    (void*)(&cuArrayCreate_error),
+    (void*)(&cuArrayGetDescriptor_error),
+    (void*)(&cuArray3DCreate_error),
+    (void*)(&cuArray3DGetDescriptor_error),
+    (void*)(&cuTexRefSetAddress_error),
+    (void*)(&cuTexRefSetAddress2D_error),
+    (void*)(&cuTexRefGetAddress_error),
+    (void*)(&cuGraphicsResourceGetMappedPointer_error),
+    (void*)(&cuCtxDestroy_error),
+    (void*)(&cuCtxPopCurrent_error),
+    (void*)(&cuCtxPushCurrent_error),
+    (void*)(&cuStreamDestroy_error),
+    (void*)(&cuEventDestroy_error),
+    (void*)(&cuMemcpyHtoD_v2_error),
+    (void*)(&cuMemcpyDtoH_v2_error),
+    (void*)(&cuMemcpyDtoD_v2_error),
+    (void*)(&cuMemcpyDtoA_v2_error),
+    (void*)(&cuMemcpyAtoD_v2_error),
+    (void*)(&cuMemcpyHtoA_v2_error),
+    (void*)(&cuMemcpyAtoH_v2_error),
+    (void*)(&cuMemcpyAtoA_v2_error),
+    (void*)(&cuMemcpyHtoAAsync_v2_error),
+    (void*)(&cuMemcpyAtoHAsync_v2_error),
+    (void*)(&cuMemcpy2D_v2_error),
+    (void*)(&cuMemcpy2DUnaligned_v2_error),
+    (void*)(&cuMemcpy3D_v2_error),
+    (void*)(&cuMemcpyHtoDAsync_v2_error),
+    (void*)(&cuMemcpyDtoHAsync_v2_error),
+    (void*)(&cuMemcpyDtoDAsync_v2_error),
+    (void*)(&cuMemcpy2DAsync_v2_error),
+    (void*)(&cuMemcpy3DAsync_v2_error),
+    (void*)(&cuMemsetD8_v2_error),
+    (void*)(&cuMemsetD16_v2_error),
+    (void*)(&cuMemsetD32_v2_error),
+    (void*)(&cuMemsetD2D8_v2_error),
+    (void*)(&cuMemsetD2D16_v2_error),
+    (void*)(&cuMemsetD2D32_v2_error),
+    (void*)(&cuMemcpy_error),
+    (void*)(&cuMemcpyAsync_error),
+    (void*)(&cuMemcpyPeer_error),
+    (void*)(&cuMemcpyPeerAsync_error),
+    (void*)(&cuMemcpy3DPeer_error),
+    (void*)(&cuMemcpy3DPeerAsync_error),
+    (void*)(&cuMemsetD8Async_error),
+    (void*)(&cuMemsetD16Async_error),
+    (void*)(&cuMemsetD32Async_error),
+    (void*)(&cuMemsetD2D8Async_error),
+    (void*)(&cuMemsetD2D16Async_error),
+    (void*)(&cuMemsetD2D32Async_error),
+    (void*)(&cuStreamGetPriority_error),
+    (void*)(&cuStreamGetFlags_error),
+    (void*)(&cuStreamGetCtx_error),
+    (void*)(&cuStreamWaitEvent_error),
+    (void*)(&cuStreamAddCallback_error),
+    (void*)(&cuStreamAttachMemAsync_error),
+    (void*)(&cuStreamQuery_error),
+    (void*)(&cuStreamSynchronize_error),
+    (void*)(&cuEventRecord_error),
+    (void*)(&cuLaunchKernel_error),
+    (void*)(&cuLaunchHostFunc_error),
+    (void*)(&cuGraphicsMapResources_error),
+    (void*)(&cuGraphicsUnmapResources_error),
+    (void*)(&cuStreamWriteValue32_error),
+    (void*)(&cuStreamWaitValue32_error),
+    (void*)(&cuStreamWriteValue64_error),
+    (void*)(&cuStreamWaitValue64_error),
+    (void*)(&cuStreamBatchMemOp_error),
+    (void*)(&cuMemPrefetchAsync_error),
+    (void*)(&cuLaunchCooperativeKernel_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_error),
+    (void*)(&cuStreamBeginCapture_error),
+    (void*)(&cuStreamBeginCapture_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_error),
+    (void*)(&cuStreamEndCapture_error),
+    (void*)(&cuStreamIsCapturing_error),
+    (void*)(&cuStreamGetCaptureInfo_error),
+    (void*)(&cuGraphLaunch_error),
+    (void*)(&cuProfilerInitialize_error),
+    (void*)(&cuProfilerStart_error),
+    (void*)(&cuProfilerStop_error)};
+static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
+    "cuGetErrorName",
+    "cuInit",
+    "cuDriverGetVersion",
+    "cuDeviceGet",
+    "cuDeviceGetCount",
+    "cuDeviceGetName",
+    "cuDeviceGetUuid",
+    "cuDeviceTotalMem_v2",
+    "cuDeviceGetAttribute",
+    "cuDeviceGetNvSciSyncAttributes",
+    "cuDeviceGetProperties",
+    "cuDeviceComputeCapability",
+    "cuDevicePrimaryCtxRetain",
+    "cuDevicePrimaryCtxRelease",
+    "cuDevicePrimaryCtxSetFlags",
+    "cuDevicePrimaryCtxGetState",
+    "cuDevicePrimaryCtxReset",
+    "cuCtxCreate_v2",
+    "cuCtxDestroy_v2",
+    "cuCtxPushCurrent_v2",
+    "cuCtxPopCurrent_v2",
+    "cuCtxSetCurrent",
+    "cuCtxGetCurrent",
+    "cuCtxGetDevice",
+    "cuCtxGetFlags",
+    "cuCtxSynchronize",
+    "cuCtxSetLimit",
+    "cuCtxGetLimit",
+    "cuCtxGetCacheConfig",
+    "cuCtxSetCacheConfig",
+    "cuCtxGetSharedMemConfig",
+    "cuCtxSetSharedMemConfig",
+    "cuCtxGetApiVersion",
+    "cuCtxGetStreamPriorityRange",
+    "cuCtxAttach",
+    "cuCtxDetach",
+    "cuModuleLoad",
+    "cuModuleLoadData",
+    "cuModuleLoadDataEx",
+    "cuModuleLoadFatBinary",
+    "cuModuleUnload",
+    "cuModuleGetFunction",
+    "cuModuleGetGlobal_v2",
+    "cuModuleGetTexRef",
+    "cuModuleGetSurfRef",
+    "cuLinkCreate_v2",
+    "cuLinkAddData_v2",
+    "cuLinkAddFile_v2",
+    "cuLinkComplete",
+    "cuLinkDestroy",
+    "cuMemGetInfo_v2",
+    "cuMemAlloc_v2",
+    "cuMemAllocPitch_v2",
+    "cuMemFree_v2",
+    "cuMemGetAddressRange_v2",
+    "cuMemAllocHost_v2",
+    "cuMemFreeHost",
+    "cuMemHostAlloc",
+    "cuMemHostGetDevicePointer_v2",
+    "cuMemHostGetFlags",
+    "cuMemAllocManaged",
+    "cuDeviceGetByPCIBusId",
+    "cuDeviceGetPCIBusId",
+    "cuIpcGetEventHandle",
+    "cuIpcOpenEventHandle",
+    "cuIpcGetMemHandle",
+    "cuIpcOpenMemHandle",
+    "cuIpcCloseMemHandle",
+    "cuMemHostRegister_v2",
+    "cuMemHostUnregister",
+    "cuMemcpy_ptds",
+    "cuMemcpyPeer_ptds",
+    "cuMemcpyHtoD_v2_ptds",
+    "cuMemcpyDtoH_v2_ptds",
+    "cuMemcpyDtoD_v2_ptds",
+    "cuMemcpyDtoA_v2_ptds",
+    "cuMemcpyAtoD_v2_ptds",
+    "cuMemcpyHtoA_v2_ptds",
+    "cuMemcpyAtoH_v2_ptds",
+    "cuMemcpyAtoA_v2_ptds",
+    "cuMemcpy2D_v2_ptds",
+    "cuMemcpy2DUnaligned_v2_ptds",
+    "cuMemcpy3D_v2_ptds",
+    "cuMemcpy3DPeer_ptds",
+    "cuMemcpyAsync_ptsz",
+    "cuMemcpyPeerAsync_ptsz",
+    "cuMemcpyHtoDAsync_v2_ptsz",
+    "cuMemcpyDtoHAsync_v2_ptsz",
+    "cuMemcpyDtoDAsync_v2_ptsz",
+    "cuMemcpyHtoAAsync_v2_ptsz",
+    "cuMemcpyAtoHAsync_v2_ptsz",
+    "cuMemcpy2DAsync_v2_ptsz",
+    "cuMemcpy3DAsync_v2_ptsz",
+    "cuMemcpy3DPeerAsync_ptsz",
+    "cuMemsetD8_v2_ptds",
+    "cuMemsetD16_v2_ptds",
+    "cuMemsetD32_v2_ptds",
+    "cuMemsetD2D8_v2_ptds",
+    "cuMemsetD2D16_v2_ptds",
+    "cuMemsetD2D32_v2_ptds",
+    "cuMemsetD8Async_ptsz",
+    "cuMemsetD16Async_ptsz",
+    "cuMemsetD32Async_ptsz",
+    "cuMemsetD2D8Async_ptsz",
+    "cuMemsetD2D16Async_ptsz",
+    "cuMemsetD2D32Async_ptsz",
+    "cuArrayCreate_v2",
+    "cuArrayGetDescriptor_v2",
+    "cuArrayDestroy",
+    "cuArray3DCreate_v2",
+    "cuArray3DGetDescriptor_v2",
+    "cuMipmappedArrayCreate",
+    "cuMipmappedArrayGetLevel",
+    "cuMipmappedArrayDestroy",
+    "cuMemAddressReserve",
+    "cuMemAddressFree",
+    "cuMemCreate",
+    "cuMemRelease",
+    "cuMemMap",
+    "cuMemUnmap",
+    "cuMemSetAccess",
+    "cuMemGetAccess",
+    "cuMemExportToShareableHandle",
+    "cuMemImportFromShareableHandle",
+    "cuMemGetAllocationGranularity",
+    "cuMemGetAllocationPropertiesFromHandle",
+    "cuPointerGetAttribute",
+    "cuMemPrefetchAsync_ptsz",
+    "cuMemAdvise",
+    "cuMemRangeGetAttribute",
+    "cuMemRangeGetAttributes",
+    "cuPointerSetAttribute",
+    "cuPointerGetAttributes",
+    "cuStreamCreate",
+    "cuStreamCreateWithPriority",
+    "cuStreamGetPriority_ptsz",
+    "cuStreamGetFlags_ptsz",
+    "cuStreamGetCtx_ptsz",
+    "cuStreamWaitEvent_ptsz",
+    "cuStreamAddCallback_ptsz",
+    "cuStreamBeginCapture_v2_ptsz",
+    "cuThreadExchangeStreamCaptureMode",
+    "cuStreamEndCapture_ptsz",
+    "cuStreamIsCapturing_ptsz",
+    "cuStreamGetCaptureInfo_ptsz",
+    "cuStreamAttachMemAsync_ptsz",
+    "cuStreamQuery_ptsz",
+    "cuStreamSynchronize_ptsz",
+    "cuStreamDestroy_v2",
+    "cuEventCreate",
+    "cuEventRecord_ptsz",
+    "cuEventQuery",
+    "cuEventSynchronize",
+    "cuEventDestroy_v2",
+    "cuEventElapsedTime",
+    "cuImportExternalMemory",
+    "cuExternalMemoryGetMappedBuffer",
+    "cuExternalMemoryGetMappedMipmappedArray",
+    "cuDestroyExternalMemory",
+    "cuImportExternalSemaphore",
+    "cuSignalExternalSemaphoresAsync_ptsz",
+    "cuWaitExternalSemaphoresAsync_ptsz",
+    "cuDestroyExternalSemaphore",
+    "cuStreamWaitValue32_ptsz",
+    "cuStreamWaitValue64_ptsz",
+    "cuStreamWriteValue32_ptsz",
+    "cuStreamWriteValue64_ptsz",
+    "cuStreamBatchMemOp_ptsz",
+    "cuFuncGetAttribute",
+    "cuFuncSetAttribute",
+    "cuFuncSetCacheConfig",
+    "cuFuncSetSharedMemConfig",
+    "cuLaunchKernel_ptsz",
+    "cuLaunchCooperativeKernel_ptsz",
+    "cuLaunchCooperativeKernelMultiDevice",
+    "cuLaunchHostFunc_ptsz",
+    "cuFuncSetBlockShape",
+    "cuFuncSetSharedSize",
+    "cuParamSetSize",
+    "cuParamSeti",
+    "cuParamSetf",
+    "cuParamSetv",
+    "cuLaunch",
+    "cuLaunchGrid",
+    "cuLaunchGridAsync",
+    "cuParamSetTexRef",
+    "cuGraphCreate",
+    "cuGraphAddKernelNode",
+    "cuGraphKernelNodeGetParams",
+    "cuGraphKernelNodeSetParams",
+    "cuGraphAddMemcpyNode",
+    "cuGraphMemcpyNodeGetParams",
+    "cuGraphMemcpyNodeSetParams",
+    "cuGraphAddMemsetNode",
+    "cuGraphMemsetNodeGetParams",
+    "cuGraphMemsetNodeSetParams",
+    "cuGraphAddHostNode",
+    "cuGraphHostNodeGetParams",
+    "cuGraphHostNodeSetParams",
+    "cuGraphAddChildGraphNode",
+    "cuGraphChildGraphNodeGetGraph",
+    "cuGraphAddEmptyNode",
+    "cuGraphClone",
+    "cuGraphNodeFindInClone",
+    "cuGraphNodeGetType",
+    "cuGraphGetNodes",
+    "cuGraphGetRootNodes",
+    "cuGraphGetEdges",
+    "cuGraphNodeGetDependencies",
+    "cuGraphNodeGetDependentNodes",
+    "cuGraphAddDependencies",
+    "cuGraphRemoveDependencies",
+    "cuGraphDestroyNode",
+    "cuGraphInstantiate",
+    "cuGraphExecKernelNodeSetParams",
+    "cuGraphExecMemcpyNodeSetParams",
+    "cuGraphExecMemsetNodeSetParams",
+    "cuGraphExecHostNodeSetParams",
+    "cuGraphLaunch_ptsz",
+    "cuGraphExecDestroy",
+    "cuGraphDestroy",
+    "cuGraphExecUpdate",
+    "cuOccupancyMaxActiveBlocksPerMultiprocessor",
+    "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags",
+    "cuOccupancyMaxPotentialBlockSize",
+    "cuOccupancyMaxPotentialBlockSizeWithFlags",
+    "cuTexRefSetArray",
+    "cuTexRefSetMipmappedArray",
+    "cuTexRefSetAddress_v2",
+    "cuTexRefSetAddress2D_v3",
+    "cuTexRefSetFormat",
+    "cuTexRefSetAddressMode",
+    "cuTexRefSetFilterMode",
+    "cuTexRefSetMipmapFilterMode",
+    "cuTexRefSetMipmapLevelBias",
+    "cuTexRefSetMipmapLevelClamp",
+    "cuTexRefSetMaxAnisotropy",
+    "cuTexRefSetBorderColor",
+    "cuTexRefSetFlags",
+    "cuTexRefGetAddress_v2",
+    "cuTexRefGetArray",
+    "cuTexRefGetMipmappedArray",
+    "cuTexRefGetAddressMode",
+    "cuTexRefGetFilterMode",
+    "cuTexRefGetFormat",
+    "cuTexRefGetMipmapFilterMode",
+    "cuTexRefGetMipmapLevelBias",
+    "cuTexRefGetMipmapLevelClamp",
+    "cuTexRefGetMaxAnisotropy",
+    "cuTexRefGetBorderColor",
+    "cuTexRefGetFlags",
+    "cuTexRefCreate",
+    "cuTexRefDestroy",
+    "cuSurfRefSetArray",
+    "cuSurfRefGetArray",
+    "cuTexObjectCreate",
+    "cuTexObjectDestroy",
+    "cuTexObjectGetResourceDesc",
+    "cuTexObjectGetTextureDesc",
+    "cuTexObjectGetResourceViewDesc",
+    "cuSurfObjectCreate",
+    "cuSurfObjectDestroy",
+    "cuSurfObjectGetResourceDesc",
+    "cuDeviceCanAccessPeer",
+    "cuCtxEnablePeerAccess",
+    "cuCtxDisablePeerAccess",
+    "cuDeviceGetP2PAttribute",
+    "cuGraphicsUnregisterResource",
+    "cuGraphicsSubResourceGetMappedArray",
+    "cuGraphicsResourceGetMappedMipmappedArray",
+    "cuGraphicsResourceGetMappedPointer_v2",
+    "cuGraphicsResourceSetMapFlags_v2",
+    "cuGraphicsMapResources_ptsz",
+    "cuGraphicsUnmapResources_ptsz",
+    "cuGetExportTable",
+    "cuMemHostRegister",
+    "cuGraphicsResourceSetMapFlags",
+    "cuLinkCreate",
+    "cuLinkAddData",
+    "cuLinkAddFile",
+    "cuTexRefSetAddress2D_v2",
+    "cuDeviceTotalMem",
+    "cuCtxCreate",
+    "cuModuleGetGlobal",
+    "cuMemGetInfo",
+    "cuMemAlloc",
+    "cuMemAllocPitch",
+    "cuMemFree",
+    "cuMemGetAddressRange",
+    "cuMemAllocHost",
+    "cuMemHostGetDevicePointer",
+    "cuMemcpyHtoD",
+    "cuMemcpyDtoH",
+    "cuMemcpyDtoD",
+    "cuMemcpyDtoA",
+    "cuMemcpyAtoD",
+    "cuMemcpyHtoA",
+    "cuMemcpyAtoH",
+    "cuMemcpyAtoA",
+    "cuMemcpyHtoAAsync",
+    "cuMemcpyAtoHAsync",
+    "cuMemcpy2D",
+    "cuMemcpy2DUnaligned",
+    "cuMemcpy3D",
+    "cuMemcpyHtoDAsync",
+    "cuMemcpyDtoHAsync",
+    "cuMemcpyDtoDAsync",
+    "cuMemcpy2DAsync",
+    "cuMemcpy3DAsync",
+    "cuMemsetD8",
+    "cuMemsetD16",
+    "cuMemsetD32",
+    "cuMemsetD2D8",
+    "cuMemsetD2D16",
+    "cuMemsetD2D32",
+    "cuArrayCreate",
+    "cuArrayGetDescriptor",
+    "cuArray3DCreate",
+    "cuArray3DGetDescriptor",
+    "cuTexRefSetAddress",
+    "cuTexRefSetAddress2D",
+    "cuTexRefGetAddress",
+    "cuGraphicsResourceGetMappedPointer",
+    "cuCtxDestroy",
+    "cuCtxPopCurrent",
+    "cuCtxPushCurrent",
+    "cuStreamDestroy",
+    "cuEventDestroy",
+    "cuMemcpyHtoD_v2",
+    "cuMemcpyDtoH_v2",
+    "cuMemcpyDtoD_v2",
+    "cuMemcpyDtoA_v2",
+    "cuMemcpyAtoD_v2",
+    "cuMemcpyHtoA_v2",
+    "cuMemcpyAtoH_v2",
+    "cuMemcpyAtoA_v2",
+    "cuMemcpyHtoAAsync_v2",
+    "cuMemcpyAtoHAsync_v2",
+    "cuMemcpy2D_v2",
+    "cuMemcpy2DUnaligned_v2",
+    "cuMemcpy3D_v2",
+    "cuMemcpyHtoDAsync_v2",
+    "cuMemcpyDtoHAsync_v2",
+    "cuMemcpyDtoDAsync_v2",
+    "cuMemcpy2DAsync_v2",
+    "cuMemcpy3DAsync_v2",
+    "cuMemsetD8_v2",
+    "cuMemsetD16_v2",
+    "cuMemsetD32_v2",
+    "cuMemsetD2D8_v2",
+    "cuMemsetD2D16_v2",
+    "cuMemsetD2D32_v2",
+    "cuMemcpy",
+    "cuMemcpyAsync",
+    "cuMemcpyPeer",
+    "cuMemcpyPeerAsync",
+    "cuMemcpy3DPeer",
+    "cuMemcpy3DPeerAsync",
+    "cuMemsetD8Async",
+    "cuMemsetD16Async",
+    "cuMemsetD32Async",
+    "cuMemsetD2D8Async",
+    "cuMemsetD2D16Async",
+    "cuMemsetD2D32Async",
+    "cuStreamGetPriority",
+    "cuStreamGetFlags",
+    "cuStreamGetCtx",
+    "cuStreamWaitEvent",
+    "cuStreamAddCallback",
+    "cuStreamAttachMemAsync",
+    "cuStreamQuery",
+    "cuStreamSynchronize",
+    "cuEventRecord",
+    "cuLaunchKernel",
+    "cuLaunchHostFunc",
+    "cuGraphicsMapResources",
+    "cuGraphicsUnmapResources",
+    "cuStreamWriteValue32",
+    "cuStreamWaitValue32",
+    "cuStreamWriteValue64",
+    "cuStreamWaitValue64",
+    "cuStreamBatchMemOp",
+    "cuMemPrefetchAsync",
+    "cuLaunchCooperativeKernel",
+    "cuSignalExternalSemaphoresAsync",
+    "cuWaitExternalSemaphoresAsync",
+    "cuStreamBeginCapture",
+    "cuStreamBeginCapture_ptsz",
+    "cuStreamBeginCapture_v2",
+    "cuStreamEndCapture",
+    "cuStreamIsCapturing",
+    "cuStreamGetCaptureInfo",
+    "cuGraphLaunch",
+    "cuProfilerInitialize",
+    "cuProfilerStart",
+    "cuProfilerStop"};
+
+static void load_library() {
+    static bool done = false;
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lg{mtx};
+
+    if (done)
+        return;
+
+    void* handle = get_library_handle();
+    for (size_t i = 0; i < NR_FUNC; ++i) {
+        void* func;
+        if (!handle) {
+            func = nullptr;
+        } else {
+            func = resolve_library_func(handle, g_func_name[i]);
+        }
+        if (!func) {
+            func = g_func_table_error[i];
+        }
+        __atomic_store_n(g_func_table + i, func, __ATOMIC_RELAXED);
+    }
+    done = true;
+}
+
+CUresult _WRAPLIB_API_CALL cuGetErrorString(CUresult arg0, const char **arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUresult, const char **);
+    ON_ENTRY(cuGetErrorString);
+    f_ptr_t f = (f_ptr_t)(g_func_table[0]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGetErrorName(CUresult arg0, const char **arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUresult, const char **);
+    ON_ENTRY(cuGetErrorName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[1]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuInit(unsigned int arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int);
+    ON_ENTRY(cuInit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[2]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDriverGetVersion(int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *);
+    ON_ENTRY(cuDriverGetVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[3]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGet(CUdevice *arg0, int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, int);
+    ON_ENTRY(cuDeviceGet);
+    f_ptr_t f = (f_ptr_t)(g_func_table[4]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetCount(int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *);
+    ON_ENTRY(cuDeviceGetCount);
+    f_ptr_t f = (f_ptr_t)(g_func_table[5]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetName(char *arg0, int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
+    ON_ENTRY(cuDeviceGetName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[6]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetUuid(CUuuid *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUuuid *, CUdevice);
+    ON_ENTRY(cuDeviceGetUuid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2(size_t *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUdevice);
+    ON_ENTRY(cuDeviceTotalMem_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_attribute, CUdevice);
+    ON_ENTRY(cuDeviceGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes(void *arg0, CUdevice arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdevice, int);
+    ON_ENTRY(cuDeviceGetNvSciSyncAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetProperties(CUdevprop *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevprop *, CUdevice);
+    ON_ENTRY(cuDeviceGetProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability(int *arg0, int *arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUdevice);
+    ON_ENTRY(cuDeviceComputeCapability);
+    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain(CUcontext *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRetain);
+    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRelease);
+    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags(CUdevice arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int);
+    ON_ENTRY(cuDevicePrimaryCtxSetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[15]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState(CUdevice arg0, unsigned int *arg1, int *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int *, int *);
+    ON_ENTRY(cuDevicePrimaryCtxGetState);
+    f_ptr_t f = (f_ptr_t)(g_func_table[16]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxReset);
+    f_ptr_t f = (f_ptr_t)(g_func_table[17]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxCreate_v2(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
+    ON_ENTRY(cuCtxCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[18]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[19]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxPushCurrent_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxPopCurrent_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[21]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetCurrent(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxSetCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[22]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetCurrent(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxGetCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[23]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetDevice(CUdevice *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *);
+    ON_ENTRY(cuCtxGetDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[24]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetFlags(unsigned int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *);
+    ON_ENTRY(cuCtxGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[25]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSynchronize() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuCtxSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[26]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetLimit(CUlimit arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlimit, size_t);
+    ON_ENTRY(cuCtxSetLimit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[27]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetLimit(size_t *arg0, CUlimit arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUlimit);
+    ON_ENTRY(cuCtxGetLimit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[28]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig(CUfunc_cache *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache *);
+    ON_ENTRY(cuCtxGetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[29]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig(CUfunc_cache arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache);
+    ON_ENTRY(cuCtxSetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[30]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig(CUsharedconfig *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig *);
+    ON_ENTRY(cuCtxGetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[31]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig(CUsharedconfig arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig);
+    ON_ENTRY(cuCtxSetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[32]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion(CUcontext arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int *);
+    ON_ENTRY(cuCtxGetApiVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[33]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange(int *arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *);
+    ON_ENTRY(cuCtxGetStreamPriorityRange);
+    f_ptr_t f = (f_ptr_t)(g_func_table[34]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxAttach(CUcontext *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int);
+    ON_ENTRY(cuCtxAttach);
+    f_ptr_t f = (f_ptr_t)(g_func_table[35]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDetach(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDetach);
+    f_ptr_t f = (f_ptr_t)(g_func_table[36]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoad(CUmodule *arg0, const char *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const char *);
+    ON_ENTRY(cuModuleLoad);
+    f_ptr_t f = (f_ptr_t)(g_func_table[37]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadData(CUmodule *arg0, const void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
+    ON_ENTRY(cuModuleLoadData);
+    f_ptr_t f = (f_ptr_t)(g_func_table[38]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuModuleLoadDataEx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[39]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary(CUmodule *arg0, const void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
+    ON_ENTRY(cuModuleLoadFatBinary);
+    f_ptr_t f = (f_ptr_t)(g_func_table[40]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleUnload(CUmodule arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule);
+    ON_ENTRY(cuModuleUnload);
+    f_ptr_t f = (f_ptr_t)(g_func_table[41]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetFunction(CUfunction *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetFunction);
+    f_ptr_t f = (f_ptr_t)(g_func_table[42]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetGlobal_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[43]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetTexRef(CUtexref *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetTexRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[44]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetSurfRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[45]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLinkCreate_v2(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
+    ON_ENTRY(cuLinkCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[46]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddData_v2(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddData_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[47]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddFile_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[48]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuLinkComplete(CUlinkState arg0, void **arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, void **, size_t *);
+    ON_ENTRY(cuLinkComplete);
+    f_ptr_t f = (f_ptr_t)(g_func_table[49]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLinkDestroy(CUlinkState arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState);
+    ON_ENTRY(cuLinkDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[50]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2(size_t *arg0, size_t *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, size_t *);
+    ON_ENTRY(cuMemGetInfo_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[51]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAlloc_v2(CUdeviceptr *arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t);
+    ON_ENTRY(cuMemAlloc_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[52]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, size_t, size_t, unsigned int);
+    ON_ENTRY(cuMemAllocPitch_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[53]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemFree_v2(CUdeviceptr arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
+    ON_ENTRY(cuMemFree_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[54]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUdeviceptr);
+    ON_ENTRY(cuMemGetAddressRange_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[55]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2(void **arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t);
+    ON_ENTRY(cuMemAllocHost_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[56]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemFreeHost(void *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
+    ON_ENTRY(cuMemFreeHost);
+    f_ptr_t f = (f_ptr_t)(g_func_table[57]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostAlloc(void **arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t, unsigned int);
+    ON_ENTRY(cuMemHostAlloc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[58]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, void *, unsigned int);
+    ON_ENTRY(cuMemHostGetDevicePointer_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[59]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetFlags(unsigned int *arg0, void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, void *);
+    ON_ENTRY(cuMemHostGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[60]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocManaged(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, unsigned int);
+    ON_ENTRY(cuMemAllocManaged);
+    f_ptr_t f = (f_ptr_t)(g_func_table[61]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId(CUdevice *arg0, const char *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, const char *);
+    ON_ENTRY(cuDeviceGetByPCIBusId);
+    f_ptr_t f = (f_ptr_t)(g_func_table[62]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId(char *arg0, int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
+    ON_ENTRY(cuDeviceGetPCIBusId);
+    f_ptr_t f = (f_ptr_t)(g_func_table[63]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle(CUipcEventHandle *arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcEventHandle *, CUevent);
+    ON_ENTRY(cuIpcGetEventHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[64]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle(CUevent *arg0, CUipcEventHandle arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, CUipcEventHandle);
+    ON_ENTRY(cuIpcOpenEventHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[65]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle(CUipcMemHandle *arg0, CUdeviceptr arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcMemHandle *, CUdeviceptr);
+    ON_ENTRY(cuIpcGetMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[66]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUipcMemHandle, unsigned int);
+    ON_ENTRY(cuIpcOpenMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[67]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle(CUdeviceptr arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
+    ON_ENTRY(cuIpcCloseMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[68]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2(void *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
+    ON_ENTRY(cuMemHostRegister_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[69]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostUnregister(void *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
+    ON_ENTRY(cuMemHostUnregister);
+    f_ptr_t f = (f_ptr_t)(g_func_table[70]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpy_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[71]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
+    ON_ENTRY(cuMemcpyPeer_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[72]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[73]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoH_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[74]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[75]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[76]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[77]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[78]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoH_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[79]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[80]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2D_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[81]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2DUnaligned_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[82]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds(const CUDA_MEMCPY3D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuMemcpy3D_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[83]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds(const CUDA_MEMCPY3D_PEER *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
+    ON_ENTRY(cuMemcpy3DPeer_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[84]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[85]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
+    ON_ENTRY(cuMemcpyPeerAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[86]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[87]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[88]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[89]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[90]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[91]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[92]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[93]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
+    ON_ENTRY(cuMemcpy3DPeerAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[94]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
+    ON_ENTRY(cuMemsetD8_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[95]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
+    ON_ENTRY(cuMemsetD16_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[96]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
+    ON_ENTRY(cuMemsetD32_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[97]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D8_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[98]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D16_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[99]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D32_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[100]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
+    ON_ENTRY(cuMemsetD8Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[101]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
+    ON_ENTRY(cuMemsetD16Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[102]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
+    ON_ENTRY(cuMemsetD32Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[103]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D8Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[104]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D16Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[105]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D32Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[106]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuArrayCreate_v2(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR *);
+    ON_ENTRY(cuArrayCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[107]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR *, CUarray);
+    ON_ENTRY(cuArrayGetDescriptor_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[108]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayDestroy(CUarray arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray);
+    ON_ENTRY(cuArrayDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[109]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *);
+    ON_ENTRY(cuArray3DCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[110]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR *, CUarray);
+    ON_ENTRY(cuArray3DGetDescriptor_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[111]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int);
+    ON_ENTRY(cuMipmappedArrayCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[112]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUmipmappedArray, unsigned int);
+    ON_ENTRY(cuMipmappedArrayGetLevel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[113]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy(CUmipmappedArray arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray);
+    ON_ENTRY(cuMipmappedArrayDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[114]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemAddressReserve(CUdeviceptr *arg0, size_t arg1, size_t arg2, CUdeviceptr arg3, unsigned long long arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, size_t, CUdeviceptr, unsigned long long);
+    ON_ENTRY(cuMemAddressReserve);
+    f_ptr_t f = (f_ptr_t)(g_func_table[115]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemAddressFree(CUdeviceptr arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t);
+    ON_ENTRY(cuMemAddressFree);
+    f_ptr_t f = (f_ptr_t)(g_func_table[116]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemCreate(CUmemGenericAllocationHandle *arg0, size_t arg1, const CUmemAllocationProp *arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, size_t, const CUmemAllocationProp *, unsigned long long);
+    ON_ENTRY(cuMemCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[117]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemRelease(CUmemGenericAllocationHandle arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle);
+    ON_ENTRY(cuMemRelease);
+    f_ptr_t f = (f_ptr_t)(g_func_table[118]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemMap(CUdeviceptr arg0, size_t arg1, size_t arg2, CUmemGenericAllocationHandle arg3, unsigned long long arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long);
+    ON_ENTRY(cuMemMap);
+    f_ptr_t f = (f_ptr_t)(g_func_table[119]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemUnmap(CUdeviceptr arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t);
+    ON_ENTRY(cuMemUnmap);
+    f_ptr_t f = (f_ptr_t)(g_func_table[120]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemSetAccess(CUdeviceptr arg0, size_t arg1, const CUmemAccessDesc *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, const CUmemAccessDesc *, size_t);
+    ON_ENTRY(cuMemSetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[121]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAccess(unsigned long long *arg0, const CUmemLocation *arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned long long *, const CUmemLocation *, CUdeviceptr);
+    ON_ENTRY(cuMemGetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[122]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle(void *arg0, CUmemGenericAllocationHandle arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long);
+    ON_ENTRY(cuMemExportToShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[123]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle(CUmemGenericAllocationHandle *arg0, void *arg1, CUmemAllocationHandleType arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, void *, CUmemAllocationHandleType);
+    ON_ENTRY(cuMemImportFromShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[124]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity(size_t *arg0, const CUmemAllocationProp *arg1, CUmemAllocationGranularity_flags arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, const CUmemAllocationProp *, CUmemAllocationGranularity_flags);
+    ON_ENTRY(cuMemGetAllocationGranularity);
+    f_ptr_t f = (f_ptr_t)(g_func_table[125]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp *arg0, CUmemGenericAllocationHandle arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemAllocationProp *, CUmemGenericAllocationHandle);
+    ON_ENTRY(cuMemGetAllocationPropertiesFromHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[126]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuPointerGetAttribute(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUpointer_attribute, CUdeviceptr);
+    ON_ENTRY(cuPointerGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[127]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[128]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemAdvise(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUmem_advise, CUdevice);
+    ON_ENTRY(cuMemAdvise);
+    f_ptr_t f = (f_ptr_t)(g_func_table[129]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemRangeGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[130]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemRangeGetAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[131]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuPointerSetAttribute(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void *, CUpointer_attribute, CUdeviceptr);
+    ON_ENTRY(cuPointerSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[132]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuPointerGetAttributes(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUpointer_attribute *, void **, CUdeviceptr);
+    ON_ENTRY(cuPointerGetAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[133]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCreate(CUstream *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int);
+    ON_ENTRY(cuStreamCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[134]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority(CUstream *arg0, unsigned int arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int, int);
+    ON_ENTRY(cuStreamCreateWithPriority);
+    f_ptr_t f = (f_ptr_t)(g_func_table[135]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz(CUstream arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
+    ON_ENTRY(cuStreamGetPriority_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[136]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz(CUstream arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
+    ON_ENTRY(cuStreamGetFlags_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[137]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[138]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
+    ON_ENTRY(cuStreamWaitEvent_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[139]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
+    ON_ENTRY(cuStreamAddCallback_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[140]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[141]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstreamCaptureMode *);
+    ON_ENTRY(cuThreadExchangeStreamCaptureMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[142]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[143]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[144]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[145]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
+    ON_ENTRY(cuStreamAttachMemAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[146]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamQuery_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[147]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamSynchronize_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[148]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[149]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventCreate(CUevent *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, unsigned int);
+    ON_ENTRY(cuEventCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[150]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz(CUevent arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
+    ON_ENTRY(cuEventRecord_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[151]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventQuery(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventQuery);
+    f_ptr_t f = (f_ptr_t)(g_func_table[152]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventSynchronize(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[153]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventDestroy_v2(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[154]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventElapsedTime(float *arg0, CUevent arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUevent, CUevent);
+    ON_ENTRY(cuEventElapsedTime);
+    f_ptr_t f = (f_ptr_t)(g_func_table[155]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalMemory(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[156]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedBuffer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[157]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[158]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory(CUexternalMemory arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory);
+    ON_ENTRY(cuDestroyExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[159]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[160]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[161]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[162]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore(CUexternalSemaphore arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore);
+    ON_ENTRY(cuDestroyExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[163]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue32_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[164]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[165]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue32_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[166]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[167]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
+    ON_ENTRY(cuStreamBatchMemOp_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[168]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuFuncGetAttribute(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction_attribute, CUfunction);
+    ON_ENTRY(cuFuncGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[169]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetAttribute(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunction_attribute, int);
+    ON_ENTRY(cuFuncSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[170]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig(CUfunction arg0, CUfunc_cache arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunc_cache);
+    ON_ENTRY(cuFuncSetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[171]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig(CUfunction arg0, CUsharedconfig arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUsharedconfig);
+    ON_ENTRY(cuFuncSetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[172]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
+    ON_ENTRY(cuLaunchKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[173]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[174]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int);
+    ON_ENTRY(cuLaunchCooperativeKernelMultiDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[175]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[176]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape(CUfunction arg0, int arg1, int arg2, int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, int);
+    ON_ENTRY(cuFuncSetBlockShape);
+    f_ptr_t f = (f_ptr_t)(g_func_table[177]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize(CUfunction arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
+    ON_ENTRY(cuFuncSetSharedSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[178]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetSize(CUfunction arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
+    ON_ENTRY(cuParamSetSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[179]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuParamSeti(CUfunction arg0, int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, unsigned int);
+    ON_ENTRY(cuParamSeti);
+    f_ptr_t f = (f_ptr_t)(g_func_table[180]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetf(CUfunction arg0, int arg1, float arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, float);
+    ON_ENTRY(cuParamSetf);
+    f_ptr_t f = (f_ptr_t)(g_func_table[181]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetv(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, void *, unsigned int);
+    ON_ENTRY(cuParamSetv);
+    f_ptr_t f = (f_ptr_t)(g_func_table[182]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLaunch(CUfunction arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction);
+    ON_ENTRY(cuLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[183]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchGrid(CUfunction arg0, int arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int);
+    ON_ENTRY(cuLaunchGrid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[184]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchGridAsync(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, CUstream);
+    ON_ENTRY(cuLaunchGridAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[185]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetTexRef(CUfunction arg0, int arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, CUtexref);
+    ON_ENTRY(cuParamSetTexRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[186]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphCreate(CUgraph *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, unsigned int);
+    ON_ENTRY(cuGraphCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[187]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddKernelNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[188]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[189]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[190]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphAddMemcpyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[191]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[192]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[193]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphAddMemsetNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[194]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[195]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[196]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddHostNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddHostNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[197]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[198]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[199]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph);
+    ON_ENTRY(cuGraphAddChildGraphNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[200]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph(CUgraphNode arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraph *);
+    ON_ENTRY(cuGraphChildGraphNodeGetGraph);
+    f_ptr_t f = (f_ptr_t)(g_func_table[201]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddEmptyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[202]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphClone(CUgraph *arg0, CUgraph arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, CUgraph);
+    ON_ENTRY(cuGraphClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[203]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraphNode, CUgraph);
+    ON_ENTRY(cuGraphNodeFindInClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[204]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetType(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNodeType *);
+    ON_ENTRY(cuGraphNodeGetType);
+    f_ptr_t f = (f_ptr_t)(g_func_table[205]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[206]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetRootNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[207]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetEdges(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetEdges);
+    f_ptr_t f = (f_ptr_t)(g_func_table[208]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[209]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependentNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[210]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[211]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphRemoveDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[212]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroyNode(CUgraphNode arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode);
+    ON_ENTRY(cuGraphDestroyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[213]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphInstantiate(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t);
+    ON_ENTRY(cuGraphInstantiate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[214]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[215]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMCPY3D *arg2, CUcontext arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphExecMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[216]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMSET_NODE_PARAMS *arg2, CUcontext arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphExecMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[217]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_HOST_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[218]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[219]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecDestroy(CUgraphExec arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec);
+    ON_ENTRY(cuGraphExecDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[220]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroy(CUgraph arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph);
+    ON_ENTRY(cuGraphDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[221]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecUpdate(CUgraphExec arg0, CUgraph arg1, CUgraphNode *arg2, CUgraphExecUpdateResult *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraph, CUgraphNode *, CUgraphExecUpdateResult *);
+    ON_ENTRY(cuGraphExecUpdate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[222]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t);
+    ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[223]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t, unsigned int);
+    ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[224]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int);
+    ON_ENTRY(cuOccupancyMaxPotentialBlockSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[225]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int);
+    ON_ENTRY(cuOccupancyMaxPotentialBlockSizeWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[226]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetArray(CUtexref arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray, unsigned int);
+    ON_ENTRY(cuTexRefSetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[227]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUmipmappedArray, unsigned int);
+    ON_ENTRY(cuTexRefSetMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[228]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUtexref, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[229]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress2D_v3);
+    f_ptr_t f = (f_ptr_t)(g_func_table[230]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFormat(CUtexref arg0, CUarray_format arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray_format, int);
+    ON_ENTRY(cuTexRefSetFormat);
+    f_ptr_t f = (f_ptr_t)(g_func_table[231]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode(CUtexref arg0, int arg1, CUaddress_mode arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, int, CUaddress_mode);
+    ON_ENTRY(cuTexRefSetAddressMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[232]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode(CUtexref arg0, CUfilter_mode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
+    ON_ENTRY(cuTexRefSetFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[233]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode(CUtexref arg0, CUfilter_mode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
+    ON_ENTRY(cuTexRefSetMipmapFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[234]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias(CUtexref arg0, float arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float);
+    ON_ENTRY(cuTexRefSetMipmapLevelBias);
+    f_ptr_t f = (f_ptr_t)(g_func_table[235]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp(CUtexref arg0, float arg1, float arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float, float);
+    ON_ENTRY(cuTexRefSetMipmapLevelClamp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[236]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy(CUtexref arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
+    ON_ENTRY(cuTexRefSetMaxAnisotropy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[237]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor(CUtexref arg0, float *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float *);
+    ON_ENTRY(cuTexRefSetBorderColor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[238]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFlags(CUtexref arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
+    ON_ENTRY(cuTexRefSetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[239]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2(CUdeviceptr *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUtexref);
+    ON_ENTRY(cuTexRefGetAddress_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[240]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetArray(CUarray *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUtexref);
+    ON_ENTRY(cuTexRefGetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[241]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray(CUmipmappedArray *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[242]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUaddress_mode *, CUtexref, int);
+    ON_ENTRY(cuTexRefGetAddressMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[243]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
+    ON_ENTRY(cuTexRefGetFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[244]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFormat(CUarray_format *arg0, int *arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray_format *, int *, CUtexref);
+    ON_ENTRY(cuTexRefGetFormat);
+    f_ptr_t f = (f_ptr_t)(g_func_table[245]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[246]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias(float *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapLevelBias);
+    f_ptr_t f = (f_ptr_t)(g_func_table[247]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp(float *arg0, float *arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, float *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapLevelClamp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[248]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy(int *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUtexref);
+    ON_ENTRY(cuTexRefGetMaxAnisotropy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[249]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor(float *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
+    ON_ENTRY(cuTexRefGetBorderColor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[250]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFlags(unsigned int *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref);
+    ON_ENTRY(cuTexRefGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[251]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefCreate(CUtexref *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *);
+    ON_ENTRY(cuTexRefCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[252]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefDestroy(CUtexref arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref);
+    ON_ENTRY(cuTexRefDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[253]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuSurfRefSetArray(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref, CUarray, unsigned int);
+    ON_ENTRY(cuSurfRefSetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[254]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuSurfRefGetArray(CUarray *arg0, CUsurfref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUsurfref);
+    ON_ENTRY(cuSurfRefGetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[255]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectCreate(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *);
+    ON_ENTRY(cuTexObjectCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[256]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectDestroy(CUtexObject arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject);
+    ON_ENTRY(cuTexObjectDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[257]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetResourceDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[258]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_TEXTURE_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetTextureDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[259]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_VIEW_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetResourceViewDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[260]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectCreate(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject *, const CUDA_RESOURCE_DESC *);
+    ON_ENTRY(cuSurfObjectCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[261]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy(CUsurfObject arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject);
+    ON_ENTRY(cuSurfObjectDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[262]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUsurfObject);
+    ON_ENTRY(cuSurfObjectGetResourceDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[263]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer(int *arg0, CUdevice arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceCanAccessPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[264]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess(CUcontext arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int);
+    ON_ENTRY(cuCtxEnablePeerAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[265]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDisablePeerAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[266]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_P2PAttribute, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceGetP2PAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[267]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource(CUgraphicsResource arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource);
+    ON_ENTRY(cuGraphicsUnregisterResource);
+    f_ptr_t f = (f_ptr_t)(g_func_table[268]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUgraphicsResource, unsigned int, unsigned int);
+    ON_ENTRY(cuGraphicsSubResourceGetMappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[269]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[270]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedPointer_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[271]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2(CUgraphicsResource arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
+    ON_ENTRY(cuGraphicsResourceSetMapFlags_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[272]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsMapResources_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[273]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsUnmapResources_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[274]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGetExportTable(const void **arg0, const CUuuid *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void **, const CUuuid *);
+    ON_ENTRY(cuGetExportTable);
+    f_ptr_t f = (f_ptr_t)(g_func_table[275]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostRegister(void *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
+    ON_ENTRY(cuMemHostRegister);
+    f_ptr_t f = (f_ptr_t)(g_func_table[276]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags(CUgraphicsResource arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
+    ON_ENTRY(cuGraphicsResourceSetMapFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[277]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLinkCreate(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
+    ON_ENTRY(cuLinkCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[278]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddData(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddData);
+    f_ptr_t f = (f_ptr_t)(g_func_table[279]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddFile(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddFile);
+    f_ptr_t f = (f_ptr_t)(g_func_table[280]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress2D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[281]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceTotalMem(unsigned int *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUdevice);
+    ON_ENTRY(cuDeviceTotalMem);
+    f_ptr_t f = (f_ptr_t)(g_func_table[282]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxCreate(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
+    ON_ENTRY(cuCtxCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[283]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetGlobal(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetGlobal);
+    f_ptr_t f = (f_ptr_t)(g_func_table[284]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetInfo(unsigned int *arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, unsigned int *);
+    ON_ENTRY(cuMemGetInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[285]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAlloc(CUdeviceptr_v1 *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int);
+    ON_ENTRY(cuMemAlloc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[286]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocPitch(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int);
+    ON_ENTRY(cuMemAllocPitch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[287]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemFree(CUdeviceptr_v1 arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1);
+    ON_ENTRY(cuMemFree);
+    f_ptr_t f = (f_ptr_t)(g_func_table[288]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAddressRange(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1);
+    ON_ENTRY(cuMemGetAddressRange);
+    f_ptr_t f = (f_ptr_t)(g_func_table[289]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocHost(void **arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, unsigned int);
+    ON_ENTRY(cuMemAllocHost);
+    f_ptr_t f = (f_ptr_t)(g_func_table[290]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, void *, unsigned int);
+    ON_ENTRY(cuMemHostGetDevicePointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[291]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int);
+    ON_ENTRY(cuMemcpyHtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[292]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoH);
+    f_ptr_t f = (f_ptr_t)(g_func_table[293]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[294]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[295]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[296]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int);
+    ON_ENTRY(cuMemcpyHtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[297]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoH);
+    f_ptr_t f = (f_ptr_t)(g_func_table[298]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[299]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[300]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[301]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D(const CUDA_MEMCPY2D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
+    ON_ENTRY(cuMemcpy2D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[302]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned(const CUDA_MEMCPY2D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
+    ON_ENTRY(cuMemcpy2DUnaligned);
+    f_ptr_t f = (f_ptr_t)(g_func_table[303]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D(const CUDA_MEMCPY3D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *);
+    ON_ENTRY(cuMemcpy3D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[304]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[305]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[306]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[307]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[308]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[309]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned char, unsigned int);
+    ON_ENTRY(cuMemsetD8);
+    f_ptr_t f = (f_ptr_t)(g_func_table[310]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned short, unsigned int);
+    ON_ENTRY(cuMemsetD16);
+    f_ptr_t f = (f_ptr_t)(g_func_table[311]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[312]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D8);
+    f_ptr_t f = (f_ptr_t)(g_func_table[313]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D16);
+    f_ptr_t f = (f_ptr_t)(g_func_table[314]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[315]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuArrayCreate(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *);
+    ON_ENTRY(cuArrayCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[316]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray);
+    ON_ENTRY(cuArrayGetDescriptor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[317]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DCreate(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *);
+    ON_ENTRY(cuArray3DCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[318]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray);
+    ON_ENTRY(cuArray3DGetDescriptor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[319]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuTexRefSetAddress);
+    f_ptr_t f = (f_ptr_t)(g_func_table[320]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuTexRefSetAddress2D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[321]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddress(CUdeviceptr_v1 *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, CUtexref);
+    ON_ENTRY(cuTexRefGetAddress);
+    f_ptr_t f = (f_ptr_t)(g_func_table[322]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedPointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[323]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDestroy(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[324]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPopCurrent(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxPopCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[325]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPushCurrent(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxPushCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[326]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamDestroy(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[327]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventDestroy(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[328]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[329]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoH_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[330]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[331]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[332]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[333]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[334]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoH_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[335]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[336]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[337]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[338]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[339]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2DUnaligned_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[340]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2(const CUDA_MEMCPY3D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuMemcpy3D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[341]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[342]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[343]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[344]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[345]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[346]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8_v2(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
+    ON_ENTRY(cuMemsetD8_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[347]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16_v2(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
+    ON_ENTRY(cuMemsetD16_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[348]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32_v2(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
+    ON_ENTRY(cuMemsetD32_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[349]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D8_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[350]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D16_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[351]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D32_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[352]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[353]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAsync(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[354]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeer(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
+    ON_ENTRY(cuMemcpyPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[355]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
+    ON_ENTRY(cuMemcpyPeerAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[356]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
+    ON_ENTRY(cuMemcpy3DPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[357]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
+    ON_ENTRY(cuMemcpy3DPeerAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[358]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8Async(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
+    ON_ENTRY(cuMemsetD8Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[359]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16Async(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
+    ON_ENTRY(cuMemsetD16Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[360]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32Async(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
+    ON_ENTRY(cuMemsetD32Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[361]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D8Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[362]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D16Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[363]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D32Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[364]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetPriority(CUstream arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
+    ON_ENTRY(cuStreamGetPriority);
+    f_ptr_t f = (f_ptr_t)(g_func_table[365]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetFlags(CUstream arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
+    ON_ENTRY(cuStreamGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[366]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[367]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitEvent(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
+    ON_ENTRY(cuStreamWaitEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[368]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAddCallback(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
+    ON_ENTRY(cuStreamAddCallback);
+    f_ptr_t f = (f_ptr_t)(g_func_table[369]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
+    ON_ENTRY(cuStreamAttachMemAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[370]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamQuery(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamQuery);
+    f_ptr_t f = (f_ptr_t)(g_func_table[371]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSynchronize(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[372]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecord(CUevent arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
+    ON_ENTRY(cuEventRecord);
+    f_ptr_t f = (f_ptr_t)(g_func_table[373]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
+    ON_ENTRY(cuLaunchKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[374]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[375]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsMapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsMapResources);
+    f_ptr_t f = (f_ptr_t)(g_func_table[376]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsUnmapResources);
+    f_ptr_t f = (f_ptr_t)(g_func_table[377]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[378]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[379]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[380]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[381]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
+    ON_ENTRY(cuStreamBatchMemOp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[382]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[383]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[384]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[385]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[386]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[387]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[388]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[389]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[390]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing);
+    f_ptr_t f = (f_ptr_t)(g_func_table[391]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[392]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[393]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuProfilerInitialize(const char *arg0, const char *arg1, CUoutput_mode arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const char *, const char *, CUoutput_mode);
+    ON_ENTRY(cuProfilerInitialize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[394]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuProfilerStart() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuProfilerStart);
+    f_ptr_t f = (f_ptr_t)(g_func_table[395]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuProfilerStop() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuProfilerStop);
+    f_ptr_t f = (f_ptr_t)(g_func_table[396]);
+    return f();
+}
diff --git a/dnn/cuda-stub/src/libcuda-wrap_11.1.h b/dnn/cuda-stub/src/libcuda-wrap_11.1.h
new file mode 100644
index 0000000000000000000000000000000000000000..e528c56e49a1704132c459529d4886a11041c3c8
--- /dev/null
+++ b/dnn/cuda-stub/src/libcuda-wrap_11.1.h
@@ -0,0 +1,6990 @@
+// generated by wraplib.py
+// --- begin functions to be implemented
+#ifndef _WRAPLIB_API_CALL
+#define _WRAPLIB_API_CALL
+#endif
+#ifndef _WRAPLIB_CALLBACK
+#define _WRAPLIB_CALLBACK
+#endif
+#ifndef ON_ENTRY
+#define ON_ENTRY(x)
+#endif
+static void* get_library_handle();
+static void* resolve_library_func(void* , const char*);
+namespace {
+template<typename T> T on_init_failed(int func_idx);
+}
+// --- end functions to be implemented
+#include <mutex>
+#include <cstddef>
+static void load_library();
+static CUresult _WRAPLIB_API_CALL cuGetErrorString_init(CUresult arg0, const char **arg1) {
+    load_library();
+    return cuGetErrorString(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorString_error(CUresult, const char **) {
+    return on_init_failed<CUresult >(0);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorName_init(CUresult arg0, const char **arg1) {
+    load_library();
+    return cuGetErrorName(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorName_error(CUresult, const char **) {
+    return on_init_failed<CUresult >(1);
+}
+static CUresult _WRAPLIB_API_CALL cuInit_init(unsigned int arg0) {
+    load_library();
+    return cuInit(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuInit_error(unsigned int) {
+    return on_init_failed<CUresult >(2);
+}
+static CUresult _WRAPLIB_API_CALL cuDriverGetVersion_init(int *arg0) {
+    load_library();
+    return cuDriverGetVersion(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDriverGetVersion_error(int *) {
+    return on_init_failed<CUresult >(3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGet_init(CUdevice *arg0, int arg1) {
+    load_library();
+    return cuDeviceGet(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGet_error(CUdevice *, int) {
+    return on_init_failed<CUresult >(4);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetCount_init(int *arg0) {
+    load_library();
+    return cuDeviceGetCount(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetCount_error(int *) {
+    return on_init_failed<CUresult >(5);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetName_init(char *arg0, int arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetName(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetName_error(char *, int, CUdevice) {
+    return on_init_failed<CUresult >(6);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_init(CUuuid *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetUuid(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_error(CUuuid *, CUdevice) {
+    return on_init_failed<CUresult >(7);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetLuid_init(char *arg0, unsigned int *arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetLuid(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetLuid_error(char *, unsigned int *, CUdevice) {
+    return on_init_failed<CUresult >(8);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_init(size_t *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceTotalMem_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_error(size_t *, CUdevice) {
+    return on_init_failed<CUresult >(9);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetTexture1DLinearMaxWidth_init(size_t *arg0, CUarray_format arg1, unsigned arg2, CUdevice arg3) {
+    load_library();
+    return cuDeviceGetTexture1DLinearMaxWidth(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetTexture1DLinearMaxWidth_error(size_t *, CUarray_format, unsigned, CUdevice) {
+    return on_init_failed<CUresult >(10);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_init(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_error(int *, CUdevice_attribute, CUdevice) {
+    return on_init_failed<CUresult >(11);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes_init(void *arg0, CUdevice arg1, int arg2) {
+    load_library();
+    return cuDeviceGetNvSciSyncAttributes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes_error(void *, CUdevice, int) {
+    return on_init_failed<CUresult >(12);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_init(CUdevprop *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_error(CUdevprop *, CUdevice) {
+    return on_init_failed<CUresult >(13);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_init(int *arg0, int *arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceComputeCapability(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_error(int *, int *, CUdevice) {
+    return on_init_failed<CUresult >(14);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_init(CUcontext *arg0, CUdevice arg1) {
+    load_library();
+    return cuDevicePrimaryCtxRetain(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_error(CUcontext *, CUdevice) {
+    return on_init_failed<CUresult >(15);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_v2_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxRelease_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_v2_error(CUdevice) {
+    return on_init_failed<CUresult >(16);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_v2_init(CUdevice arg0, unsigned int arg1) {
+    load_library();
+    return cuDevicePrimaryCtxSetFlags_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_v2_error(CUdevice, unsigned int) {
+    return on_init_failed<CUresult >(17);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_init(CUdevice arg0, unsigned int *arg1, int *arg2) {
+    load_library();
+    return cuDevicePrimaryCtxGetState(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_error(CUdevice, unsigned int *, int *) {
+    return on_init_failed<CUresult >(18);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_v2_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxReset_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_v2_error(CUdevice) {
+    return on_init_failed<CUresult >(19);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    load_library();
+    return cuCtxCreate_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_error(CUcontext *, unsigned int, CUdevice) {
+    return on_init_failed<CUresult >(20);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_error(CUcontext) {
+    return on_init_failed<CUresult >(21);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_init(CUcontext arg0) {
+    load_library();
+    return cuCtxPushCurrent_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_error(CUcontext) {
+    return on_init_failed<CUresult >(22);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxPopCurrent_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_error(CUcontext *) {
+    return on_init_failed<CUresult >(23);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_init(CUcontext arg0) {
+    load_library();
+    return cuCtxSetCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_error(CUcontext) {
+    return on_init_failed<CUresult >(24);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxGetCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_error(CUcontext *) {
+    return on_init_failed<CUresult >(25);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_init(CUdevice *arg0) {
+    load_library();
+    return cuCtxGetDevice(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_error(CUdevice *) {
+    return on_init_failed<CUresult >(26);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_init(unsigned int *arg0) {
+    load_library();
+    return cuCtxGetFlags(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_error(unsigned int *) {
+    return on_init_failed<CUresult >(27);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_init() {
+    load_library();
+    return cuCtxSynchronize();
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_error() {
+    return on_init_failed<CUresult >(28);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_init(CUlimit arg0, size_t arg1) {
+    load_library();
+    return cuCtxSetLimit(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_error(CUlimit, size_t) {
+    return on_init_failed<CUresult >(29);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_init(size_t *arg0, CUlimit arg1) {
+    load_library();
+    return cuCtxGetLimit(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_error(size_t *, CUlimit) {
+    return on_init_failed<CUresult >(30);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_init(CUfunc_cache *arg0) {
+    load_library();
+    return cuCtxGetCacheConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_error(CUfunc_cache *) {
+    return on_init_failed<CUresult >(31);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_init(CUfunc_cache arg0) {
+    load_library();
+    return cuCtxSetCacheConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_error(CUfunc_cache) {
+    return on_init_failed<CUresult >(32);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_init(CUsharedconfig *arg0) {
+    load_library();
+    return cuCtxGetSharedMemConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_error(CUsharedconfig *) {
+    return on_init_failed<CUresult >(33);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_init(CUsharedconfig arg0) {
+    load_library();
+    return cuCtxSetSharedMemConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_error(CUsharedconfig) {
+    return on_init_failed<CUresult >(34);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_init(CUcontext arg0, unsigned int *arg1) {
+    load_library();
+    return cuCtxGetApiVersion(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_error(CUcontext, unsigned int *) {
+    return on_init_failed<CUresult >(35);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_init(int *arg0, int *arg1) {
+    load_library();
+    return cuCtxGetStreamPriorityRange(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_error(int *, int *) {
+    return on_init_failed<CUresult >(36);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxResetPersistingL2Cache_init() {
+    load_library();
+    return cuCtxResetPersistingL2Cache();
+}
+static CUresult _WRAPLIB_API_CALL cuCtxResetPersistingL2Cache_error() {
+    return on_init_failed<CUresult >(37);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxAttach_init(CUcontext *arg0, unsigned int arg1) {
+    load_library();
+    return cuCtxAttach(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxAttach_error(CUcontext *, unsigned int) {
+    return on_init_failed<CUresult >(38);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDetach_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDetach(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDetach_error(CUcontext) {
+    return on_init_failed<CUresult >(39);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoad_init(CUmodule *arg0, const char *arg1) {
+    load_library();
+    return cuModuleLoad(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoad_error(CUmodule *, const char *) {
+    return on_init_failed<CUresult >(40);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadData_init(CUmodule *arg0, const void *arg1) {
+    load_library();
+    return cuModuleLoadData(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadData_error(CUmodule *, const void *) {
+    return on_init_failed<CUresult >(41);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_init(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
+    load_library();
+    return cuModuleLoadDataEx(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_error(CUmodule *, const void *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(42);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_init(CUmodule *arg0, const void *arg1) {
+    load_library();
+    return cuModuleLoadFatBinary(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_error(CUmodule *, const void *) {
+    return on_init_failed<CUresult >(43);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleUnload_init(CUmodule arg0) {
+    load_library();
+    return cuModuleUnload(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleUnload_error(CUmodule) {
+    return on_init_failed<CUresult >(44);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_init(CUfunction *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetFunction(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_error(CUfunction *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(45);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_init(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
+    load_library();
+    return cuModuleGetGlobal_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_error(CUdeviceptr *, size_t *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(46);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_init(CUtexref *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetTexRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_error(CUtexref *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(47);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_init(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetSurfRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_error(CUsurfref *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(48);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    load_library();
+    return cuLinkCreate_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
+    return on_init_failed<CUresult >(49);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    load_library();
+    return cuLinkAddData_v2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(50);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    load_library();
+    return cuLinkAddFile_v2(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(51);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkComplete_init(CUlinkState arg0, void **arg1, size_t *arg2) {
+    load_library();
+    return cuLinkComplete(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkComplete_error(CUlinkState, void **, size_t *) {
+    return on_init_failed<CUresult >(52);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkDestroy_init(CUlinkState arg0) {
+    load_library();
+    return cuLinkDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkDestroy_error(CUlinkState) {
+    return on_init_failed<CUresult >(53);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_init(size_t *arg0, size_t *arg1) {
+    load_library();
+    return cuMemGetInfo_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_error(size_t *, size_t *) {
+    return on_init_failed<CUresult >(54);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_init(CUdeviceptr *arg0, size_t arg1) {
+    load_library();
+    return cuMemAlloc_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_error(CUdeviceptr *, size_t) {
+    return on_init_failed<CUresult >(55);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_init(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
+    load_library();
+    return cuMemAllocPitch_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_error(CUdeviceptr *, size_t *, size_t, size_t, unsigned int) {
+    return on_init_failed<CUresult >(56);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_v2_init(CUdeviceptr arg0) {
+    load_library();
+    return cuMemFree_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_v2_error(CUdeviceptr) {
+    return on_init_failed<CUresult >(57);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_init(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuMemGetAddressRange_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_error(CUdeviceptr *, size_t *, CUdeviceptr) {
+    return on_init_failed<CUresult >(58);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_init(void **arg0, size_t arg1) {
+    load_library();
+    return cuMemAllocHost_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_error(void **, size_t) {
+    return on_init_failed<CUresult >(59);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeHost_init(void *arg0) {
+    load_library();
+    return cuMemFreeHost(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeHost_error(void *) {
+    return on_init_failed<CUresult >(60);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_init(void **arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostAlloc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_error(void **, size_t, unsigned int) {
+    return on_init_failed<CUresult >(61);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_init(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostGetDevicePointer_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_error(CUdeviceptr *, void *, unsigned int) {
+    return on_init_failed<CUresult >(62);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_init(unsigned int *arg0, void *arg1) {
+    load_library();
+    return cuMemHostGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_error(unsigned int *, void *) {
+    return on_init_failed<CUresult >(63);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_init(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemAllocManaged(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_error(CUdeviceptr *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(64);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_init(CUdevice *arg0, const char *arg1) {
+    load_library();
+    return cuDeviceGetByPCIBusId(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_error(CUdevice *, const char *) {
+    return on_init_failed<CUresult >(65);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_init(char *arg0, int arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetPCIBusId(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_error(char *, int, CUdevice) {
+    return on_init_failed<CUresult >(66);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_init(CUipcEventHandle *arg0, CUevent arg1) {
+    load_library();
+    return cuIpcGetEventHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_error(CUipcEventHandle *, CUevent) {
+    return on_init_failed<CUresult >(67);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_init(CUevent *arg0, CUipcEventHandle arg1) {
+    load_library();
+    return cuIpcOpenEventHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_error(CUevent *, CUipcEventHandle) {
+    return on_init_failed<CUresult >(68);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_init(CUipcMemHandle *arg0, CUdeviceptr arg1) {
+    load_library();
+    return cuIpcGetMemHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_error(CUipcMemHandle *, CUdeviceptr) {
+    return on_init_failed<CUresult >(69);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_v2_init(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    load_library();
+    return cuIpcOpenMemHandle_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_v2_error(CUdeviceptr *, CUipcMemHandle, unsigned int) {
+    return on_init_failed<CUresult >(70);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_init(CUdeviceptr arg0) {
+    load_library();
+    return cuIpcCloseMemHandle(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_error(CUdeviceptr) {
+    return on_init_failed<CUresult >(71);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_init(void *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostRegister_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_error(void *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(72);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_init(void *arg0) {
+    load_library();
+    return cuMemHostUnregister(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_error(void *) {
+    return on_init_failed<CUresult >(73);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpy_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(74);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyPeer_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
+    return on_init_failed<CUresult >(75);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyHtoD_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_error(CUdeviceptr, const void *, size_t) {
+    return on_init_failed<CUresult >(76);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoH_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_error(void *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(77);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoD_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(78);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyDtoA_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_error(CUarray, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(79);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoD_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_error(CUdeviceptr, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(80);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyHtoA_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_error(CUarray, size_t, const void *, size_t) {
+    return on_init_failed<CUresult >(81);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoH_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_error(void *, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(82);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyAtoA_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_error(CUarray, size_t, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(83);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2D_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(84);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(85);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_init(const CUDA_MEMCPY3D *arg0) {
+    load_library();
+    return cuMemcpy3D_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_error(const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(86);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_init(const CUDA_MEMCPY3D_PEER *arg0) {
+    load_library();
+    return cuMemcpy3DPeer_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_error(const CUDA_MEMCPY3D_PEER *) {
+    return on_init_failed<CUresult >(87);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(88);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemcpyPeerAsync_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
+    return on_init_failed<CUresult >(89);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_error(CUdeviceptr, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(90);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_error(void *, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(91);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(92);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_error(CUarray, size_t, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(93);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_error(void *, CUarray, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(94);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_error(const CUDA_MEMCPY2D *, CUstream) {
+    return on_init_failed<CUresult >(95);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_error(const CUDA_MEMCPY3D *, CUstream) {
+    return on_init_failed<CUresult >(96);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DPeerAsync_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
+    return on_init_failed<CUresult >(97);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD8_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_error(CUdeviceptr, unsigned char, size_t) {
+    return on_init_failed<CUresult >(98);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD16_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_error(CUdeviceptr, unsigned short, size_t) {
+    return on_init_failed<CUresult >(99);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD32_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_error(CUdeviceptr, unsigned int, size_t) {
+    return on_init_failed<CUresult >(100);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D8_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
+    return on_init_failed<CUresult >(101);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D16_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
+    return on_init_failed<CUresult >(102);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D32_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
+    return on_init_failed<CUresult >(103);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD8Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_error(CUdeviceptr, unsigned char, size_t, CUstream) {
+    return on_init_failed<CUresult >(104);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD16Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_error(CUdeviceptr, unsigned short, size_t, CUstream) {
+    return on_init_failed<CUresult >(105);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD32Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_error(CUdeviceptr, unsigned int, size_t, CUstream) {
+    return on_init_failed<CUresult >(106);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D8Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(107);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D16Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(108);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D32Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(109);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
+    load_library();
+    return cuArrayCreate_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR *) {
+    return on_init_failed<CUresult >(110);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_init(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetDescriptor_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_error(CUDA_ARRAY_DESCRIPTOR *, CUarray) {
+    return on_init_failed<CUresult >(111);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetSparseProperties_init(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetSparseProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetSparseProperties_error(CUDA_ARRAY_SPARSE_PROPERTIES *, CUarray) {
+    return on_init_failed<CUresult >(112);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetSparseProperties_init(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUmipmappedArray arg1) {
+    load_library();
+    return cuMipmappedArrayGetSparseProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetSparseProperties_error(CUDA_ARRAY_SPARSE_PROPERTIES *, CUmipmappedArray) {
+    return on_init_failed<CUresult >(113);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayDestroy_init(CUarray arg0) {
+    load_library();
+    return cuArrayDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayDestroy_error(CUarray) {
+    return on_init_failed<CUresult >(114);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
+    load_library();
+    return cuArray3DCreate_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *) {
+    return on_init_failed<CUresult >(115);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_init(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
+    load_library();
+    return cuArray3DGetDescriptor_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_error(CUDA_ARRAY3D_DESCRIPTOR *, CUarray) {
+    return on_init_failed<CUresult >(116);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_init(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
+    load_library();
+    return cuMipmappedArrayCreate(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_error(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int) {
+    return on_init_failed<CUresult >(117);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_init(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    load_library();
+    return cuMipmappedArrayGetLevel(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_error(CUarray *, CUmipmappedArray, unsigned int) {
+    return on_init_failed<CUresult >(118);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_init(CUmipmappedArray arg0) {
+    load_library();
+    return cuMipmappedArrayDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_error(CUmipmappedArray) {
+    return on_init_failed<CUresult >(119);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressReserve_init(CUdeviceptr *arg0, size_t arg1, size_t arg2, CUdeviceptr arg3, unsigned long long arg4) {
+    load_library();
+    return cuMemAddressReserve(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressReserve_error(CUdeviceptr *, size_t, size_t, CUdeviceptr, unsigned long long) {
+    return on_init_failed<CUresult >(120);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressFree_init(CUdeviceptr arg0, size_t arg1) {
+    load_library();
+    return cuMemAddressFree(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressFree_error(CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(121);
+}
+static CUresult _WRAPLIB_API_CALL cuMemCreate_init(CUmemGenericAllocationHandle *arg0, size_t arg1, const CUmemAllocationProp *arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemCreate_error(CUmemGenericAllocationHandle *, size_t, const CUmemAllocationProp *, unsigned long long) {
+    return on_init_failed<CUresult >(122);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRelease_init(CUmemGenericAllocationHandle arg0) {
+    load_library();
+    return cuMemRelease(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRelease_error(CUmemGenericAllocationHandle) {
+    return on_init_failed<CUresult >(123);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMap_init(CUdeviceptr arg0, size_t arg1, size_t arg2, CUmemGenericAllocationHandle arg3, unsigned long long arg4) {
+    load_library();
+    return cuMemMap(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMap_error(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long) {
+    return on_init_failed<CUresult >(124);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_ptsz_init(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    load_library();
+    return cuMemMapArrayAsync_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_ptsz_error(CUarrayMapInfo *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(125);
+}
+static CUresult _WRAPLIB_API_CALL cuMemUnmap_init(CUdeviceptr arg0, size_t arg1) {
+    load_library();
+    return cuMemUnmap(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemUnmap_error(CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(126);
+}
+static CUresult _WRAPLIB_API_CALL cuMemSetAccess_init(CUdeviceptr arg0, size_t arg1, const CUmemAccessDesc *arg2, size_t arg3) {
+    load_library();
+    return cuMemSetAccess(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemSetAccess_error(CUdeviceptr, size_t, const CUmemAccessDesc *, size_t) {
+    return on_init_failed<CUresult >(127);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAccess_init(unsigned long long *arg0, const CUmemLocation *arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuMemGetAccess(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAccess_error(unsigned long long *, const CUmemLocation *, CUdeviceptr) {
+    return on_init_failed<CUresult >(128);
+}
+static CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle_init(void *arg0, CUmemGenericAllocationHandle arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemExportToShareableHandle(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle_error(void *, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long) {
+    return on_init_failed<CUresult >(129);
+}
+static CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle_init(CUmemGenericAllocationHandle *arg0, void *arg1, CUmemAllocationHandleType arg2) {
+    load_library();
+    return cuMemImportFromShareableHandle(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle_error(CUmemGenericAllocationHandle *, void *, CUmemAllocationHandleType) {
+    return on_init_failed<CUresult >(130);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity_init(size_t *arg0, const CUmemAllocationProp *arg1, CUmemAllocationGranularity_flags arg2) {
+    load_library();
+    return cuMemGetAllocationGranularity(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity_error(size_t *, const CUmemAllocationProp *, CUmemAllocationGranularity_flags) {
+    return on_init_failed<CUresult >(131);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle_init(CUmemAllocationProp *arg0, CUmemGenericAllocationHandle arg1) {
+    load_library();
+    return cuMemGetAllocationPropertiesFromHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle_error(CUmemAllocationProp *, CUmemGenericAllocationHandle) {
+    return on_init_failed<CUresult >(132);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRetainAllocationHandle_init(CUmemGenericAllocationHandle *arg0, void *arg1) {
+    load_library();
+    return cuMemRetainAllocationHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRetainAllocationHandle_error(CUmemGenericAllocationHandle *, void *) {
+    return on_init_failed<CUresult >(133);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_init(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuPointerGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_error(void *, CUpointer_attribute, CUdeviceptr) {
+    return on_init_failed<CUresult >(134);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(135);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAdvise_init(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
+    load_library();
+    return cuMemAdvise(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAdvise_error(CUdeviceptr, size_t, CUmem_advise, CUdevice) {
+    return on_init_failed<CUresult >(136);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_init(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
+    load_library();
+    return cuMemRangeGetAttribute(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_error(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(137);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_init(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
+    load_library();
+    return cuMemRangeGetAttributes(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_error(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(138);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_init(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuPointerSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_error(const void *, CUpointer_attribute, CUdeviceptr) {
+    return on_init_failed<CUresult >(139);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_init(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
+    load_library();
+    return cuPointerGetAttributes(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_error(unsigned int, CUpointer_attribute *, void **, CUdeviceptr) {
+    return on_init_failed<CUresult >(140);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreate_init(CUstream *arg0, unsigned int arg1) {
+    load_library();
+    return cuStreamCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreate_error(CUstream *, unsigned int) {
+    return on_init_failed<CUresult >(141);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_init(CUstream *arg0, unsigned int arg1, int arg2) {
+    load_library();
+    return cuStreamCreateWithPriority(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_error(CUstream *, unsigned int, int) {
+    return on_init_failed<CUresult >(142);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_init(CUstream arg0, int *arg1) {
+    load_library();
+    return cuStreamGetPriority_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_error(CUstream, int *) {
+    return on_init_failed<CUresult >(143);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_init(CUstream arg0, unsigned int *arg1) {
+    load_library();
+    return cuStreamGetFlags_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_error(CUstream, unsigned int *) {
+    return on_init_failed<CUresult >(144);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(145);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    load_library();
+    return cuStreamWaitEvent_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_error(CUstream, CUevent, unsigned int) {
+    return on_init_failed<CUresult >(146);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAddCallback_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_error(CUstream, CUstreamCallback, void *, unsigned int) {
+    return on_init_failed<CUresult >(147);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(148);
+}
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_init(CUstreamCaptureMode *arg0) {
+    load_library();
+    return cuThreadExchangeStreamCaptureMode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_error(CUstreamCaptureMode *) {
+    return on_init_failed<CUresult >(149);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(150);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(151);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(152);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(153);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(154);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamSynchronize_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(155);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_init(CUstream arg0) {
+    load_library();
+    return cuStreamDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_error(CUstream) {
+    return on_init_failed<CUresult >(156);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_ptsz_init(CUstream arg0, CUstream arg1) {
+    load_library();
+    return cuStreamCopyAttributes_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_ptsz_error(CUstream, CUstream) {
+    return on_init_failed<CUresult >(157);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_ptsz_init(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamGetAttribute_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_ptsz_error(CUstream, CUstreamAttrID, CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(158);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_ptsz_init(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamSetAttribute_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_ptsz_error(CUstream, CUstreamAttrID, const CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(159);
+}
+static CUresult _WRAPLIB_API_CALL cuEventCreate_init(CUevent *arg0, unsigned int arg1) {
+    load_library();
+    return cuEventCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventCreate_error(CUevent *, unsigned int) {
+    return on_init_failed<CUresult >(160);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_init(CUevent arg0, CUstream arg1) {
+    load_library();
+    return cuEventRecord_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_error(CUevent, CUstream) {
+    return on_init_failed<CUresult >(161);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_ptsz_init(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    load_library();
+    return cuEventRecordWithFlags_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_ptsz_error(CUevent, CUstream, unsigned int) {
+    return on_init_failed<CUresult >(162);
+}
+static CUresult _WRAPLIB_API_CALL cuEventQuery_init(CUevent arg0) {
+    load_library();
+    return cuEventQuery(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventQuery_error(CUevent) {
+    return on_init_failed<CUresult >(163);
+}
+static CUresult _WRAPLIB_API_CALL cuEventSynchronize_init(CUevent arg0) {
+    load_library();
+    return cuEventSynchronize(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventSynchronize_error(CUevent) {
+    return on_init_failed<CUresult >(164);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_init(CUevent arg0) {
+    load_library();
+    return cuEventDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_error(CUevent) {
+    return on_init_failed<CUresult >(165);
+}
+static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_init(float *arg0, CUevent arg1, CUevent arg2) {
+    load_library();
+    return cuEventElapsedTime(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_error(float *, CUevent, CUevent) {
+    return on_init_failed<CUresult >(166);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_init(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalMemory(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_error(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(167);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_init(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedBuffer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_error(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *) {
+    return on_init_failed<CUresult >(168);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_error(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *) {
+    return on_init_failed<CUresult >(169);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_init(CUexternalMemory arg0) {
+    load_library();
+    return cuDestroyExternalMemory(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_error(CUexternalMemory) {
+    return on_init_failed<CUresult >(170);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_init(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalSemaphore(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_error(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(171);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(172);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(173);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_init(CUexternalSemaphore arg0) {
+    load_library();
+    return cuDestroyExternalSemaphore(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_error(CUexternalSemaphore) {
+    return on_init_failed<CUresult >(174);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue32_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(175);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(176);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue32_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(177);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(178);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamBatchMemOp_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
+    return on_init_failed<CUresult >(179);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_init(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
+    load_library();
+    return cuFuncGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_error(int *, CUfunction_attribute, CUfunction) {
+    return on_init_failed<CUresult >(180);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_init(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    load_library();
+    return cuFuncSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_error(CUfunction, CUfunction_attribute, int) {
+    return on_init_failed<CUresult >(181);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_init(CUfunction arg0, CUfunc_cache arg1) {
+    load_library();
+    return cuFuncSetCacheConfig(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_error(CUfunction, CUfunc_cache) {
+    return on_init_failed<CUresult >(182);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_init(CUfunction arg0, CUsharedconfig arg1) {
+    load_library();
+    return cuFuncSetSharedMemConfig(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_error(CUfunction, CUsharedconfig) {
+    return on_init_failed<CUresult >(183);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    load_library();
+    return cuLaunchKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
+    return on_init_failed<CUresult >(184);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(185);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_init(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuLaunchCooperativeKernelMultiDevice(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_error(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(186);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(187);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_init(CUfunction arg0, int arg1, int arg2, int arg3) {
+    load_library();
+    return cuFuncSetBlockShape(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_error(CUfunction, int, int, int) {
+    return on_init_failed<CUresult >(188);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_init(CUfunction arg0, unsigned int arg1) {
+    load_library();
+    return cuFuncSetSharedSize(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_error(CUfunction, unsigned int) {
+    return on_init_failed<CUresult >(189);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetSize_init(CUfunction arg0, unsigned int arg1) {
+    load_library();
+    return cuParamSetSize(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetSize_error(CUfunction, unsigned int) {
+    return on_init_failed<CUresult >(190);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSeti_init(CUfunction arg0, int arg1, unsigned int arg2) {
+    load_library();
+    return cuParamSeti(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSeti_error(CUfunction, int, unsigned int) {
+    return on_init_failed<CUresult >(191);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetf_init(CUfunction arg0, int arg1, float arg2) {
+    load_library();
+    return cuParamSetf(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetf_error(CUfunction, int, float) {
+    return on_init_failed<CUresult >(192);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetv_init(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuParamSetv(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetv_error(CUfunction, int, void *, unsigned int) {
+    return on_init_failed<CUresult >(193);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunch_init(CUfunction arg0) {
+    load_library();
+    return cuLaunch(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunch_error(CUfunction) {
+    return on_init_failed<CUresult >(194);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGrid_init(CUfunction arg0, int arg1, int arg2) {
+    load_library();
+    return cuLaunchGrid(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGrid_error(CUfunction, int, int) {
+    return on_init_failed<CUresult >(195);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_init(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
+    load_library();
+    return cuLaunchGridAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_error(CUfunction, int, int, CUstream) {
+    return on_init_failed<CUresult >(196);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_init(CUfunction arg0, int arg1, CUtexref arg2) {
+    load_library();
+    return cuParamSetTexRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_error(CUfunction, int, CUtexref) {
+    return on_init_failed<CUresult >(197);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_init(CUgraph *arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_error(CUgraph *, unsigned int) {
+    return on_init_failed<CUresult >(198);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddKernelNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(199);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_init(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_error(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(200);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_init(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_error(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(201);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemcpyNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(202);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_init(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_error(CUgraphNode, CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(203);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_error(CUgraphNode, const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(204);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemsetNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(205);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_init(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_error(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(206);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_error(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(207);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddHostNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(208);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_init(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_error(CUgraphNode, CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(209);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_init(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_error(CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(210);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    load_library();
+    return cuGraphAddChildGraphNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph) {
+    return on_init_failed<CUresult >(211);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_init(CUgraphNode arg0, CUgraph *arg1) {
+    load_library();
+    return cuGraphChildGraphNodeGetGraph(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_error(CUgraphNode, CUgraph *) {
+    return on_init_failed<CUresult >(212);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddEmptyNode(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(213);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventRecordNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    load_library();
+    return cuGraphAddEventRecordNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventRecordNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent) {
+    return on_init_failed<CUresult >(214);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeGetEvent_init(CUgraphNode arg0, CUevent *arg1) {
+    load_library();
+    return cuGraphEventRecordNodeGetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeGetEvent_error(CUgraphNode, CUevent *) {
+    return on_init_failed<CUresult >(215);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeSetEvent_init(CUgraphNode arg0, CUevent arg1) {
+    load_library();
+    return cuGraphEventRecordNodeSetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeSetEvent_error(CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(216);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventWaitNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    load_library();
+    return cuGraphAddEventWaitNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventWaitNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent) {
+    return on_init_failed<CUresult >(217);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeGetEvent_init(CUgraphNode arg0, CUevent *arg1) {
+    load_library();
+    return cuGraphEventWaitNodeGetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeGetEvent_error(CUgraphNode, CUevent *) {
+    return on_init_failed<CUresult >(218);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeSetEvent_init(CUgraphNode arg0, CUevent arg1) {
+    load_library();
+    return cuGraphEventWaitNodeSetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeSetEvent_error(CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(219);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_init(CUgraph *arg0, CUgraph arg1) {
+    load_library();
+    return cuGraphClone(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_error(CUgraph *, CUgraph) {
+    return on_init_failed<CUresult >(220);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_init(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    load_library();
+    return cuGraphNodeFindInClone(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_error(CUgraphNode *, CUgraphNode, CUgraph) {
+    return on_init_failed<CUresult >(221);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_init(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    load_library();
+    return cuGraphNodeGetType(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_error(CUgraphNode, CUgraphNodeType *) {
+    return on_init_failed<CUresult >(222);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(223);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetRootNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(224);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_init(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    load_library();
+    return cuGraphGetEdges(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_error(CUgraph, CUgraphNode *, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(225);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependencies(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(226);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependentNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(227);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(228);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphRemoveDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(229);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_init(CUgraphNode arg0) {
+    load_library();
+    return cuGraphDestroyNode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_error(CUgraphNode) {
+    return on_init_failed<CUresult >(230);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_v2_init(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    load_library();
+    return cuGraphInstantiate_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_v2_error(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t) {
+    return on_init_failed<CUresult >(231);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecKernelNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(232);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMCPY3D *arg2, CUcontext arg3) {
+    load_library();
+    return cuGraphExecMemcpyNodeSetParams(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(233);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMSET_NODE_PARAMS *arg2, CUcontext arg3) {
+    load_library();
+    return cuGraphExecMemsetNodeSetParams(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(234);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_HOST_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecHostNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(235);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecChildGraphNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, CUgraph arg2) {
+    load_library();
+    return cuGraphExecChildGraphNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecChildGraphNodeSetParams_error(CUgraphExec, CUgraphNode, CUgraph) {
+    return on_init_failed<CUresult >(236);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventRecordNodeSetEvent_init(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    load_library();
+    return cuGraphExecEventRecordNodeSetEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventRecordNodeSetEvent_error(CUgraphExec, CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(237);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventWaitNodeSetEvent_init(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    load_library();
+    return cuGraphExecEventWaitNodeSetEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventWaitNodeSetEvent_error(CUgraphExec, CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(238);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_ptsz_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphUpload_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_ptsz_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(239);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(240);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_init(CUgraphExec arg0) {
+    load_library();
+    return cuGraphExecDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_error(CUgraphExec) {
+    return on_init_failed<CUresult >(241);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_init(CUgraph arg0) {
+    load_library();
+    return cuGraphDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_error(CUgraph) {
+    return on_init_failed<CUresult >(242);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecUpdate_init(CUgraphExec arg0, CUgraph arg1, CUgraphNode *arg2, CUgraphExecUpdateResult *arg3) {
+    load_library();
+    return cuGraphExecUpdate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecUpdate_error(CUgraphExec, CUgraph, CUgraphNode *, CUgraphExecUpdateResult *) {
+    return on_init_failed<CUresult >(243);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeCopyAttributes_init(CUgraphNode arg0, CUgraphNode arg1) {
+    load_library();
+    return cuGraphKernelNodeCopyAttributes(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeCopyAttributes_error(CUgraphNode, CUgraphNode) {
+    return on_init_failed<CUresult >(244);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetAttribute_init(CUgraphNode arg0, CUkernelNodeAttrID arg1, CUkernelNodeAttrValue *arg2) {
+    load_library();
+    return cuGraphKernelNodeGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetAttribute_error(CUgraphNode, CUkernelNodeAttrID, CUkernelNodeAttrValue *) {
+    return on_init_failed<CUresult >(245);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetAttribute_init(CUgraphNode arg0, CUkernelNodeAttrID arg1, const CUkernelNodeAttrValue *arg2) {
+    load_library();
+    return cuGraphKernelNodeSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetAttribute_error(CUgraphNode, CUkernelNodeAttrID, const CUkernelNodeAttrValue *) {
+    return on_init_failed<CUresult >(246);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_init(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
+    load_library();
+    return cuOccupancyMaxActiveBlocksPerMultiprocessor(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_error(int *, CUfunction, int, size_t) {
+    return on_init_failed<CUresult >(247);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
+    load_library();
+    return cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error(int *, CUfunction, int, size_t, unsigned int) {
+    return on_init_failed<CUresult >(248);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
+    load_library();
+    return cuOccupancyMaxPotentialBlockSize(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int) {
+    return on_init_failed<CUresult >(249);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
+    load_library();
+    return cuOccupancyMaxPotentialBlockSizeWithFlags(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int) {
+    return on_init_failed<CUresult >(250);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyAvailableDynamicSMemPerBlock_init(size_t *arg0, CUfunction arg1, int arg2, int arg3) {
+    load_library();
+    return cuOccupancyAvailableDynamicSMemPerBlock(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyAvailableDynamicSMemPerBlock_error(size_t *, CUfunction, int, int) {
+    return on_init_failed<CUresult >(251);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_init(CUtexref arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuTexRefSetArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_error(CUtexref, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(252);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_init(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    load_library();
+    return cuTexRefSetMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_error(CUtexref, CUmipmappedArray, unsigned int) {
+    return on_init_failed<CUresult >(253);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_init(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_error(size_t *, CUtexref, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(254);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress2D_v3(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(255);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_init(CUtexref arg0, CUarray_format arg1, int arg2) {
+    load_library();
+    return cuTexRefSetFormat(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_error(CUtexref, CUarray_format, int) {
+    return on_init_failed<CUresult >(256);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_init(CUtexref arg0, int arg1, CUaddress_mode arg2) {
+    load_library();
+    return cuTexRefSetAddressMode(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_error(CUtexref, int, CUaddress_mode) {
+    return on_init_failed<CUresult >(257);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
+    load_library();
+    return cuTexRefSetFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_error(CUtexref, CUfilter_mode) {
+    return on_init_failed<CUresult >(258);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
+    load_library();
+    return cuTexRefSetMipmapFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_error(CUtexref, CUfilter_mode) {
+    return on_init_failed<CUresult >(259);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_init(CUtexref arg0, float arg1) {
+    load_library();
+    return cuTexRefSetMipmapLevelBias(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_error(CUtexref, float) {
+    return on_init_failed<CUresult >(260);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_init(CUtexref arg0, float arg1, float arg2) {
+    load_library();
+    return cuTexRefSetMipmapLevelClamp(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_error(CUtexref, float, float) {
+    return on_init_failed<CUresult >(261);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_init(CUtexref arg0, unsigned int arg1) {
+    load_library();
+    return cuTexRefSetMaxAnisotropy(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_error(CUtexref, unsigned int) {
+    return on_init_failed<CUresult >(262);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_init(CUtexref arg0, float *arg1) {
+    load_library();
+    return cuTexRefSetBorderColor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_error(CUtexref, float *) {
+    return on_init_failed<CUresult >(263);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_init(CUtexref arg0, unsigned int arg1) {
+    load_library();
+    return cuTexRefSetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_error(CUtexref, unsigned int) {
+    return on_init_failed<CUresult >(264);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_init(CUdeviceptr *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetAddress_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_error(CUdeviceptr *, CUtexref) {
+    return on_init_failed<CUresult >(265);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_init(CUarray *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_error(CUarray *, CUtexref) {
+    return on_init_failed<CUresult >(266);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_init(CUmipmappedArray *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmappedArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_error(CUmipmappedArray *, CUtexref) {
+    return on_init_failed<CUresult >(267);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_init(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
+    load_library();
+    return cuTexRefGetAddressMode(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_error(CUaddress_mode *, CUtexref, int) {
+    return on_init_failed<CUresult >(268);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_error(CUfilter_mode *, CUtexref) {
+    return on_init_failed<CUresult >(269);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_init(CUarray_format *arg0, int *arg1, CUtexref arg2) {
+    load_library();
+    return cuTexRefGetFormat(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_error(CUarray_format *, int *, CUtexref) {
+    return on_init_failed<CUresult >(270);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmapFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_error(CUfilter_mode *, CUtexref) {
+    return on_init_failed<CUresult >(271);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_init(float *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmapLevelBias(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_error(float *, CUtexref) {
+    return on_init_failed<CUresult >(272);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_init(float *arg0, float *arg1, CUtexref arg2) {
+    load_library();
+    return cuTexRefGetMipmapLevelClamp(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_error(float *, float *, CUtexref) {
+    return on_init_failed<CUresult >(273);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_init(int *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMaxAnisotropy(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_error(int *, CUtexref) {
+    return on_init_failed<CUresult >(274);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_init(float *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetBorderColor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_error(float *, CUtexref) {
+    return on_init_failed<CUresult >(275);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_init(unsigned int *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_error(unsigned int *, CUtexref) {
+    return on_init_failed<CUresult >(276);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefCreate_init(CUtexref *arg0) {
+    load_library();
+    return cuTexRefCreate(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefCreate_error(CUtexref *) {
+    return on_init_failed<CUresult >(277);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_init(CUtexref arg0) {
+    load_library();
+    return cuTexRefDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_error(CUtexref) {
+    return on_init_failed<CUresult >(278);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_init(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuSurfRefSetArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_error(CUsurfref, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(279);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_init(CUarray *arg0, CUsurfref arg1) {
+    load_library();
+    return cuSurfRefGetArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_error(CUarray *, CUsurfref) {
+    return on_init_failed<CUresult >(280);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_init(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
+    load_library();
+    return cuTexObjectCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_error(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *) {
+    return on_init_failed<CUresult >(281);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_init(CUtexObject arg0) {
+    load_library();
+    return cuTexObjectDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_error(CUtexObject) {
+    return on_init_failed<CUresult >(282);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetResourceDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(283);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_init(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetTextureDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_error(CUDA_TEXTURE_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(284);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_init(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetResourceViewDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_error(CUDA_RESOURCE_VIEW_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(285);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_init(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
+    load_library();
+    return cuSurfObjectCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_error(CUsurfObject *, const CUDA_RESOURCE_DESC *) {
+    return on_init_failed<CUresult >(286);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_init(CUsurfObject arg0) {
+    load_library();
+    return cuSurfObjectDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_error(CUsurfObject) {
+    return on_init_failed<CUresult >(287);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
+    load_library();
+    return cuSurfObjectGetResourceDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUsurfObject) {
+    return on_init_failed<CUresult >(288);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_init(int *arg0, CUdevice arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceCanAccessPeer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_error(int *, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(289);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_init(CUcontext arg0, unsigned int arg1) {
+    load_library();
+    return cuCtxEnablePeerAccess(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_error(CUcontext, unsigned int) {
+    return on_init_failed<CUresult >(290);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDisablePeerAccess(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_error(CUcontext) {
+    return on_init_failed<CUresult >(291);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_init(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    load_library();
+    return cuDeviceGetP2PAttribute(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_error(int *, CUdevice_P2PAttribute, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(292);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_init(CUgraphicsResource arg0) {
+    load_library();
+    return cuGraphicsUnregisterResource(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_error(CUgraphicsResource) {
+    return on_init_failed<CUresult >(293);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_init(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuGraphicsSubResourceGetMappedArray(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_error(CUarray *, CUgraphicsResource, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(294);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
+    load_library();
+    return cuGraphicsResourceGetMappedMipmappedArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_error(CUmipmappedArray *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(295);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_init(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
+    load_library();
+    return cuGraphicsResourceGetMappedPointer_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_error(CUdeviceptr *, size_t *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(296);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_init(CUgraphicsResource arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphicsResourceSetMapFlags_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_error(CUgraphicsResource, unsigned int) {
+    return on_init_failed<CUresult >(297);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsMapResources_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(298);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsUnmapResources_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(299);
+}
+static CUresult _WRAPLIB_API_CALL cuGetExportTable_init(const void **arg0, const CUuuid *arg1) {
+    load_library();
+    return cuGetExportTable(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetExportTable_error(const void **, const CUuuid *) {
+    return on_init_failed<CUresult >(300);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetModule_init(CUmodule *arg0, CUfunction arg1) {
+    load_library();
+    return cuFuncGetModule(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetModule_error(CUmodule *, CUfunction) {
+    return on_init_failed<CUresult >(301);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_init(void *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostRegister(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_error(void *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(302);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_init(CUgraphicsResource arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphicsResourceSetMapFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_error(CUgraphicsResource, unsigned int) {
+    return on_init_failed<CUresult >(303);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    load_library();
+    return cuLinkCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
+    return on_init_failed<CUresult >(304);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    load_library();
+    return cuLinkAddData(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(305);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    load_library();
+    return cuLinkAddFile(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(306);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress2D_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(307);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_init(unsigned int *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceTotalMem(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_error(unsigned int *, CUdevice) {
+    return on_init_failed<CUresult >(308);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    load_library();
+    return cuCtxCreate(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_error(CUcontext *, unsigned int, CUdevice) {
+    return on_init_failed<CUresult >(309);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
+    load_library();
+    return cuModuleGetGlobal(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_error(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(310);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_init(unsigned int *arg0, unsigned int *arg1) {
+    load_library();
+    return cuMemGetInfo(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_error(unsigned int *, unsigned int *) {
+    return on_init_failed<CUresult >(311);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_init(CUdeviceptr_v1 *arg0, unsigned int arg1) {
+    load_library();
+    return cuMemAlloc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_error(CUdeviceptr_v1 *, unsigned int) {
+    return on_init_failed<CUresult >(312);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemAllocPitch(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_error(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(313);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_init(CUdeviceptr_v1 arg0) {
+    load_library();
+    return cuMemFree(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_error(CUdeviceptr_v1) {
+    return on_init_failed<CUresult >(314);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
+    load_library();
+    return cuMemGetAddressRange(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_error(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1) {
+    return on_init_failed<CUresult >(315);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_init(void **arg0, unsigned int arg1) {
+    load_library();
+    return cuMemAllocHost(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_error(void **, unsigned int) {
+    return on_init_failed<CUresult >(316);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_init(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostGetDevicePointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_error(CUdeviceptr_v1 *, void *, unsigned int) {
+    return on_init_failed<CUresult >(317);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyHtoD(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_error(CUdeviceptr_v1, const void *, unsigned int) {
+    return on_init_failed<CUresult >(318);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyDtoH(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_error(void *, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(319);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyDtoD(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(320);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_init(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyDtoA(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_error(CUarray, unsigned int, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(321);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_init(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyAtoD(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_error(CUdeviceptr_v1, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(322);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyHtoA(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_error(CUarray, unsigned int, const void *, unsigned int) {
+    return on_init_failed<CUresult >(323);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyAtoH(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_error(void *, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(324);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_init(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemcpyAtoA(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_error(CUarray, unsigned int, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(325);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_error(CUarray, unsigned int, const void *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(326);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_error(void *, CUarray, unsigned int, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(327);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_init(const CUDA_MEMCPY2D_v1 *arg0) {
+    load_library();
+    return cuMemcpy2D(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_error(const CUDA_MEMCPY2D_v1 *) {
+    return on_init_failed<CUresult >(328);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_init(const CUDA_MEMCPY2D_v1 *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_error(const CUDA_MEMCPY2D_v1 *) {
+    return on_init_failed<CUresult >(329);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_init(const CUDA_MEMCPY3D_v1 *arg0) {
+    load_library();
+    return cuMemcpy3D(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_error(const CUDA_MEMCPY3D_v1 *) {
+    return on_init_failed<CUresult >(330);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_error(CUdeviceptr_v1, const void *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(331);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_error(void *, CUdeviceptr_v1, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(332);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(333);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_init(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_error(const CUDA_MEMCPY2D_v1 *, CUstream) {
+    return on_init_failed<CUresult >(334);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_init(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_error(const CUDA_MEMCPY3D_v1 *, CUstream) {
+    return on_init_failed<CUresult >(335);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_init(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD8(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_error(CUdeviceptr_v1, unsigned char, unsigned int) {
+    return on_init_failed<CUresult >(336);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_init(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD16(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_error(CUdeviceptr_v1, unsigned short, unsigned int) {
+    return on_init_failed<CUresult >(337);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD32(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_error(CUdeviceptr_v1, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(338);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D8(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_error(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(339);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D16(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_error(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(340);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D32(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_error(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(341);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
+    load_library();
+    return cuArrayCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *) {
+    return on_init_failed<CUresult >(342);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_init(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetDescriptor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_error(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray) {
+    return on_init_failed<CUresult >(343);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
+    load_library();
+    return cuArray3DCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *) {
+    return on_init_failed<CUresult >(344);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_init(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    load_library();
+    return cuArray3DGetDescriptor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_error(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray) {
+    return on_init_failed<CUresult >(345);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_init(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuTexRefSetAddress(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_error(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(346);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuTexRefSetAddress2D(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(347);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_init(CUdeviceptr_v1 *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetAddress(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_error(CUdeviceptr_v1 *, CUtexref) {
+    return on_init_failed<CUresult >(348);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
+    load_library();
+    return cuGraphicsResourceGetMappedPointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_error(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(349);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_error(CUcontext) {
+    return on_init_failed<CUresult >(350);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxPopCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_error(CUcontext *) {
+    return on_init_failed<CUresult >(351);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_init(CUcontext arg0) {
+    load_library();
+    return cuCtxPushCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_error(CUcontext) {
+    return on_init_failed<CUresult >(352);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_init(CUstream arg0) {
+    load_library();
+    return cuStreamDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_error(CUstream) {
+    return on_init_failed<CUresult >(353);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_init(CUevent arg0) {
+    load_library();
+    return cuEventDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_error(CUevent) {
+    return on_init_failed<CUresult >(354);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxRelease(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_error(CUdevice) {
+    return on_init_failed<CUresult >(355);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxReset(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_error(CUdevice) {
+    return on_init_failed<CUresult >(356);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_init(CUdevice arg0, unsigned int arg1) {
+    load_library();
+    return cuDevicePrimaryCtxSetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_error(CUdevice, unsigned int) {
+    return on_init_failed<CUresult >(357);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyHtoD_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_error(CUdeviceptr, const void *, size_t) {
+    return on_init_failed<CUresult >(358);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoH_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_error(void *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(359);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoD_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(360);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyDtoA_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_error(CUarray, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(361);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoD_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_error(CUdeviceptr, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(362);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyHtoA_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_error(CUarray, size_t, const void *, size_t) {
+    return on_init_failed<CUresult >(363);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoH_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_error(void *, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(364);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyAtoA_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_error(CUarray, size_t, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(365);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_error(CUarray, size_t, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(366);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_error(void *, CUarray, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(367);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2D_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(368);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(369);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_init(const CUDA_MEMCPY3D *arg0) {
+    load_library();
+    return cuMemcpy3D_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_error(const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(370);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_error(CUdeviceptr, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(371);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_error(void *, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(372);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(373);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_error(const CUDA_MEMCPY2D *, CUstream) {
+    return on_init_failed<CUresult >(374);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_error(const CUDA_MEMCPY3D *, CUstream) {
+    return on_init_failed<CUresult >(375);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD8_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_error(CUdeviceptr, unsigned char, size_t) {
+    return on_init_failed<CUresult >(376);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD16_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_error(CUdeviceptr, unsigned short, size_t) {
+    return on_init_failed<CUresult >(377);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD32_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_error(CUdeviceptr, unsigned int, size_t) {
+    return on_init_failed<CUresult >(378);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D8_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
+    return on_init_failed<CUresult >(379);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D16_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
+    return on_init_failed<CUresult >(380);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D32_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
+    return on_init_failed<CUresult >(381);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpy(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(382);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(383);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyPeer(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
+    return on_init_failed<CUresult >(384);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemcpyPeerAsync(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
+    return on_init_failed<CUresult >(385);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_init(const CUDA_MEMCPY3D_PEER *arg0) {
+    load_library();
+    return cuMemcpy3DPeer(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_error(const CUDA_MEMCPY3D_PEER *) {
+    return on_init_failed<CUresult >(386);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DPeerAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
+    return on_init_failed<CUresult >(387);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD8Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_error(CUdeviceptr, unsigned char, size_t, CUstream) {
+    return on_init_failed<CUresult >(388);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD16Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_error(CUdeviceptr, unsigned short, size_t, CUstream) {
+    return on_init_failed<CUresult >(389);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD32Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_error(CUdeviceptr, unsigned int, size_t, CUstream) {
+    return on_init_failed<CUresult >(390);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D8Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(391);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D16Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(392);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D32Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(393);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_init(CUstream arg0, int *arg1) {
+    load_library();
+    return cuStreamGetPriority(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_error(CUstream, int *) {
+    return on_init_failed<CUresult >(394);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_init(CUstream arg0, unsigned int *arg1) {
+    load_library();
+    return cuStreamGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_error(CUstream, unsigned int *) {
+    return on_init_failed<CUresult >(395);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(396);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    load_library();
+    return cuStreamWaitEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_error(CUstream, CUevent, unsigned int) {
+    return on_init_failed<CUresult >(397);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAddCallback(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_error(CUstream, CUstreamCallback, void *, unsigned int) {
+    return on_init_failed<CUresult >(398);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(399);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_error(CUstream) {
+    return on_init_failed<CUresult >(400);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_init(CUstream arg0) {
+    load_library();
+    return cuStreamSynchronize(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_error(CUstream) {
+    return on_init_failed<CUresult >(401);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_init(CUevent arg0, CUstream arg1) {
+    load_library();
+    return cuEventRecord(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_error(CUevent, CUstream) {
+    return on_init_failed<CUresult >(402);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_init(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    load_library();
+    return cuEventRecordWithFlags(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_error(CUevent, CUstream, unsigned int) {
+    return on_init_failed<CUresult >(403);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    load_library();
+    return cuLaunchKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
+    return on_init_failed<CUresult >(404);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(405);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsMapResources(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(406);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsUnmapResources(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(407);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue32(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(408);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue32(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(409);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(410);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(411);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamBatchMemOp(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
+    return on_init_failed<CUresult >(412);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(413);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(414);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(415);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(416);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_error(CUstream) {
+    return on_init_failed<CUresult >(417);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(418);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(419);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(420);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(421);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(422);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphUpload(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(423);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(424);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_init(CUstream arg0, CUstream arg1) {
+    load_library();
+    return cuStreamCopyAttributes(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_error(CUstream, CUstream) {
+    return on_init_failed<CUresult >(425);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_init(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_error(CUstream, CUstreamAttrID, CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(426);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_init(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_error(CUstream, CUstreamAttrID, const CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(427);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_init(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    load_library();
+    return cuIpcOpenMemHandle(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_error(CUdeviceptr *, CUipcMemHandle, unsigned int) {
+    return on_init_failed<CUresult >(428);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_init(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    load_library();
+    return cuGraphInstantiate(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_error(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t) {
+    return on_init_failed<CUresult >(429);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_init(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    load_library();
+    return cuMemMapArrayAsync(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_error(CUarrayMapInfo *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(430);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_init(const char *arg0, const char *arg1, CUoutput_mode arg2) {
+    load_library();
+    return cuProfilerInitialize(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_error(const char *, const char *, CUoutput_mode) {
+    return on_init_failed<CUresult >(431);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStart_init() {
+    load_library();
+    return cuProfilerStart();
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStart_error() {
+    return on_init_failed<CUresult >(432);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStop_init() {
+    load_library();
+    return cuProfilerStop();
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStop_error() {
+    return on_init_failed<CUresult >(433);
+}
+static constexpr size_t NR_FUNC = 434;
+static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
+    (void*)(&cuGetErrorName_init),
+    (void*)(&cuInit_init),
+    (void*)(&cuDriverGetVersion_init),
+    (void*)(&cuDeviceGet_init),
+    (void*)(&cuDeviceGetCount_init),
+    (void*)(&cuDeviceGetName_init),
+    (void*)(&cuDeviceGetUuid_init),
+    (void*)(&cuDeviceGetLuid_init),
+    (void*)(&cuDeviceTotalMem_v2_init),
+    (void*)(&cuDeviceGetTexture1DLinearMaxWidth_init),
+    (void*)(&cuDeviceGetAttribute_init),
+    (void*)(&cuDeviceGetNvSciSyncAttributes_init),
+    (void*)(&cuDeviceGetProperties_init),
+    (void*)(&cuDeviceComputeCapability_init),
+    (void*)(&cuDevicePrimaryCtxRetain_init),
+    (void*)(&cuDevicePrimaryCtxRelease_v2_init),
+    (void*)(&cuDevicePrimaryCtxSetFlags_v2_init),
+    (void*)(&cuDevicePrimaryCtxGetState_init),
+    (void*)(&cuDevicePrimaryCtxReset_v2_init),
+    (void*)(&cuCtxCreate_v2_init),
+    (void*)(&cuCtxDestroy_v2_init),
+    (void*)(&cuCtxPushCurrent_v2_init),
+    (void*)(&cuCtxPopCurrent_v2_init),
+    (void*)(&cuCtxSetCurrent_init),
+    (void*)(&cuCtxGetCurrent_init),
+    (void*)(&cuCtxGetDevice_init),
+    (void*)(&cuCtxGetFlags_init),
+    (void*)(&cuCtxSynchronize_init),
+    (void*)(&cuCtxSetLimit_init),
+    (void*)(&cuCtxGetLimit_init),
+    (void*)(&cuCtxGetCacheConfig_init),
+    (void*)(&cuCtxSetCacheConfig_init),
+    (void*)(&cuCtxGetSharedMemConfig_init),
+    (void*)(&cuCtxSetSharedMemConfig_init),
+    (void*)(&cuCtxGetApiVersion_init),
+    (void*)(&cuCtxGetStreamPriorityRange_init),
+    (void*)(&cuCtxResetPersistingL2Cache_init),
+    (void*)(&cuCtxAttach_init),
+    (void*)(&cuCtxDetach_init),
+    (void*)(&cuModuleLoad_init),
+    (void*)(&cuModuleLoadData_init),
+    (void*)(&cuModuleLoadDataEx_init),
+    (void*)(&cuModuleLoadFatBinary_init),
+    (void*)(&cuModuleUnload_init),
+    (void*)(&cuModuleGetFunction_init),
+    (void*)(&cuModuleGetGlobal_v2_init),
+    (void*)(&cuModuleGetTexRef_init),
+    (void*)(&cuModuleGetSurfRef_init),
+    (void*)(&cuLinkCreate_v2_init),
+    (void*)(&cuLinkAddData_v2_init),
+    (void*)(&cuLinkAddFile_v2_init),
+    (void*)(&cuLinkComplete_init),
+    (void*)(&cuLinkDestroy_init),
+    (void*)(&cuMemGetInfo_v2_init),
+    (void*)(&cuMemAlloc_v2_init),
+    (void*)(&cuMemAllocPitch_v2_init),
+    (void*)(&cuMemFree_v2_init),
+    (void*)(&cuMemGetAddressRange_v2_init),
+    (void*)(&cuMemAllocHost_v2_init),
+    (void*)(&cuMemFreeHost_init),
+    (void*)(&cuMemHostAlloc_init),
+    (void*)(&cuMemHostGetDevicePointer_v2_init),
+    (void*)(&cuMemHostGetFlags_init),
+    (void*)(&cuMemAllocManaged_init),
+    (void*)(&cuDeviceGetByPCIBusId_init),
+    (void*)(&cuDeviceGetPCIBusId_init),
+    (void*)(&cuIpcGetEventHandle_init),
+    (void*)(&cuIpcOpenEventHandle_init),
+    (void*)(&cuIpcGetMemHandle_init),
+    (void*)(&cuIpcOpenMemHandle_v2_init),
+    (void*)(&cuIpcCloseMemHandle_init),
+    (void*)(&cuMemHostRegister_v2_init),
+    (void*)(&cuMemHostUnregister_init),
+    (void*)(&cuMemcpy_ptds_init),
+    (void*)(&cuMemcpyPeer_ptds_init),
+    (void*)(&cuMemcpyHtoD_v2_ptds_init),
+    (void*)(&cuMemcpyDtoH_v2_ptds_init),
+    (void*)(&cuMemcpyDtoD_v2_ptds_init),
+    (void*)(&cuMemcpyDtoA_v2_ptds_init),
+    (void*)(&cuMemcpyAtoD_v2_ptds_init),
+    (void*)(&cuMemcpyHtoA_v2_ptds_init),
+    (void*)(&cuMemcpyAtoH_v2_ptds_init),
+    (void*)(&cuMemcpyAtoA_v2_ptds_init),
+    (void*)(&cuMemcpy2D_v2_ptds_init),
+    (void*)(&cuMemcpy2DUnaligned_v2_ptds_init),
+    (void*)(&cuMemcpy3D_v2_ptds_init),
+    (void*)(&cuMemcpy3DPeer_ptds_init),
+    (void*)(&cuMemcpyAsync_ptsz_init),
+    (void*)(&cuMemcpyPeerAsync_ptsz_init),
+    (void*)(&cuMemcpyHtoDAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyDtoHAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyDtoDAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyHtoAAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyAtoHAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy2DAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy3DAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy3DPeerAsync_ptsz_init),
+    (void*)(&cuMemsetD8_v2_ptds_init),
+    (void*)(&cuMemsetD16_v2_ptds_init),
+    (void*)(&cuMemsetD32_v2_ptds_init),
+    (void*)(&cuMemsetD2D8_v2_ptds_init),
+    (void*)(&cuMemsetD2D16_v2_ptds_init),
+    (void*)(&cuMemsetD2D32_v2_ptds_init),
+    (void*)(&cuMemsetD8Async_ptsz_init),
+    (void*)(&cuMemsetD16Async_ptsz_init),
+    (void*)(&cuMemsetD32Async_ptsz_init),
+    (void*)(&cuMemsetD2D8Async_ptsz_init),
+    (void*)(&cuMemsetD2D16Async_ptsz_init),
+    (void*)(&cuMemsetD2D32Async_ptsz_init),
+    (void*)(&cuArrayCreate_v2_init),
+    (void*)(&cuArrayGetDescriptor_v2_init),
+    (void*)(&cuArrayGetSparseProperties_init),
+    (void*)(&cuMipmappedArrayGetSparseProperties_init),
+    (void*)(&cuArrayDestroy_init),
+    (void*)(&cuArray3DCreate_v2_init),
+    (void*)(&cuArray3DGetDescriptor_v2_init),
+    (void*)(&cuMipmappedArrayCreate_init),
+    (void*)(&cuMipmappedArrayGetLevel_init),
+    (void*)(&cuMipmappedArrayDestroy_init),
+    (void*)(&cuMemAddressReserve_init),
+    (void*)(&cuMemAddressFree_init),
+    (void*)(&cuMemCreate_init),
+    (void*)(&cuMemRelease_init),
+    (void*)(&cuMemMap_init),
+    (void*)(&cuMemMapArrayAsync_ptsz_init),
+    (void*)(&cuMemUnmap_init),
+    (void*)(&cuMemSetAccess_init),
+    (void*)(&cuMemGetAccess_init),
+    (void*)(&cuMemExportToShareableHandle_init),
+    (void*)(&cuMemImportFromShareableHandle_init),
+    (void*)(&cuMemGetAllocationGranularity_init),
+    (void*)(&cuMemGetAllocationPropertiesFromHandle_init),
+    (void*)(&cuMemRetainAllocationHandle_init),
+    (void*)(&cuPointerGetAttribute_init),
+    (void*)(&cuMemPrefetchAsync_ptsz_init),
+    (void*)(&cuMemAdvise_init),
+    (void*)(&cuMemRangeGetAttribute_init),
+    (void*)(&cuMemRangeGetAttributes_init),
+    (void*)(&cuPointerSetAttribute_init),
+    (void*)(&cuPointerGetAttributes_init),
+    (void*)(&cuStreamCreate_init),
+    (void*)(&cuStreamCreateWithPriority_init),
+    (void*)(&cuStreamGetPriority_ptsz_init),
+    (void*)(&cuStreamGetFlags_ptsz_init),
+    (void*)(&cuStreamGetCtx_ptsz_init),
+    (void*)(&cuStreamWaitEvent_ptsz_init),
+    (void*)(&cuStreamAddCallback_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_init),
+    (void*)(&cuThreadExchangeStreamCaptureMode_init),
+    (void*)(&cuStreamEndCapture_ptsz_init),
+    (void*)(&cuStreamIsCapturing_ptsz_init),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_init),
+    (void*)(&cuStreamAttachMemAsync_ptsz_init),
+    (void*)(&cuStreamQuery_ptsz_init),
+    (void*)(&cuStreamSynchronize_ptsz_init),
+    (void*)(&cuStreamDestroy_v2_init),
+    (void*)(&cuStreamCopyAttributes_ptsz_init),
+    (void*)(&cuStreamGetAttribute_ptsz_init),
+    (void*)(&cuStreamSetAttribute_ptsz_init),
+    (void*)(&cuEventCreate_init),
+    (void*)(&cuEventRecord_ptsz_init),
+    (void*)(&cuEventRecordWithFlags_ptsz_init),
+    (void*)(&cuEventQuery_init),
+    (void*)(&cuEventSynchronize_init),
+    (void*)(&cuEventDestroy_v2_init),
+    (void*)(&cuEventElapsedTime_init),
+    (void*)(&cuImportExternalMemory_init),
+    (void*)(&cuExternalMemoryGetMappedBuffer_init),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_init),
+    (void*)(&cuDestroyExternalMemory_init),
+    (void*)(&cuImportExternalSemaphore_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuDestroyExternalSemaphore_init),
+    (void*)(&cuStreamWaitValue32_ptsz_init),
+    (void*)(&cuStreamWaitValue64_ptsz_init),
+    (void*)(&cuStreamWriteValue32_ptsz_init),
+    (void*)(&cuStreamWriteValue64_ptsz_init),
+    (void*)(&cuStreamBatchMemOp_ptsz_init),
+    (void*)(&cuFuncGetAttribute_init),
+    (void*)(&cuFuncSetAttribute_init),
+    (void*)(&cuFuncSetCacheConfig_init),
+    (void*)(&cuFuncSetSharedMemConfig_init),
+    (void*)(&cuLaunchKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_init),
+    (void*)(&cuLaunchHostFunc_ptsz_init),
+    (void*)(&cuFuncSetBlockShape_init),
+    (void*)(&cuFuncSetSharedSize_init),
+    (void*)(&cuParamSetSize_init),
+    (void*)(&cuParamSeti_init),
+    (void*)(&cuParamSetf_init),
+    (void*)(&cuParamSetv_init),
+    (void*)(&cuLaunch_init),
+    (void*)(&cuLaunchGrid_init),
+    (void*)(&cuLaunchGridAsync_init),
+    (void*)(&cuParamSetTexRef_init),
+    (void*)(&cuGraphCreate_init),
+    (void*)(&cuGraphAddKernelNode_init),
+    (void*)(&cuGraphKernelNodeGetParams_init),
+    (void*)(&cuGraphKernelNodeSetParams_init),
+    (void*)(&cuGraphAddMemcpyNode_init),
+    (void*)(&cuGraphMemcpyNodeGetParams_init),
+    (void*)(&cuGraphMemcpyNodeSetParams_init),
+    (void*)(&cuGraphAddMemsetNode_init),
+    (void*)(&cuGraphMemsetNodeGetParams_init),
+    (void*)(&cuGraphMemsetNodeSetParams_init),
+    (void*)(&cuGraphAddHostNode_init),
+    (void*)(&cuGraphHostNodeGetParams_init),
+    (void*)(&cuGraphHostNodeSetParams_init),
+    (void*)(&cuGraphAddChildGraphNode_init),
+    (void*)(&cuGraphChildGraphNodeGetGraph_init),
+    (void*)(&cuGraphAddEmptyNode_init),
+    (void*)(&cuGraphAddEventRecordNode_init),
+    (void*)(&cuGraphEventRecordNodeGetEvent_init),
+    (void*)(&cuGraphEventRecordNodeSetEvent_init),
+    (void*)(&cuGraphAddEventWaitNode_init),
+    (void*)(&cuGraphEventWaitNodeGetEvent_init),
+    (void*)(&cuGraphEventWaitNodeSetEvent_init),
+    (void*)(&cuGraphClone_init),
+    (void*)(&cuGraphNodeFindInClone_init),
+    (void*)(&cuGraphNodeGetType_init),
+    (void*)(&cuGraphGetNodes_init),
+    (void*)(&cuGraphGetRootNodes_init),
+    (void*)(&cuGraphGetEdges_init),
+    (void*)(&cuGraphNodeGetDependencies_init),
+    (void*)(&cuGraphNodeGetDependentNodes_init),
+    (void*)(&cuGraphAddDependencies_init),
+    (void*)(&cuGraphRemoveDependencies_init),
+    (void*)(&cuGraphDestroyNode_init),
+    (void*)(&cuGraphInstantiate_v2_init),
+    (void*)(&cuGraphExecKernelNodeSetParams_init),
+    (void*)(&cuGraphExecMemcpyNodeSetParams_init),
+    (void*)(&cuGraphExecMemsetNodeSetParams_init),
+    (void*)(&cuGraphExecHostNodeSetParams_init),
+    (void*)(&cuGraphExecChildGraphNodeSetParams_init),
+    (void*)(&cuGraphExecEventRecordNodeSetEvent_init),
+    (void*)(&cuGraphExecEventWaitNodeSetEvent_init),
+    (void*)(&cuGraphUpload_ptsz_init),
+    (void*)(&cuGraphLaunch_ptsz_init),
+    (void*)(&cuGraphExecDestroy_init),
+    (void*)(&cuGraphDestroy_init),
+    (void*)(&cuGraphExecUpdate_init),
+    (void*)(&cuGraphKernelNodeCopyAttributes_init),
+    (void*)(&cuGraphKernelNodeGetAttribute_init),
+    (void*)(&cuGraphKernelNodeSetAttribute_init),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_init),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init),
+    (void*)(&cuOccupancyMaxPotentialBlockSize_init),
+    (void*)(&cuOccupancyMaxPotentialBlockSizeWithFlags_init),
+    (void*)(&cuOccupancyAvailableDynamicSMemPerBlock_init),
+    (void*)(&cuTexRefSetArray_init),
+    (void*)(&cuTexRefSetMipmappedArray_init),
+    (void*)(&cuTexRefSetAddress_v2_init),
+    (void*)(&cuTexRefSetAddress2D_v3_init),
+    (void*)(&cuTexRefSetFormat_init),
+    (void*)(&cuTexRefSetAddressMode_init),
+    (void*)(&cuTexRefSetFilterMode_init),
+    (void*)(&cuTexRefSetMipmapFilterMode_init),
+    (void*)(&cuTexRefSetMipmapLevelBias_init),
+    (void*)(&cuTexRefSetMipmapLevelClamp_init),
+    (void*)(&cuTexRefSetMaxAnisotropy_init),
+    (void*)(&cuTexRefSetBorderColor_init),
+    (void*)(&cuTexRefSetFlags_init),
+    (void*)(&cuTexRefGetAddress_v2_init),
+    (void*)(&cuTexRefGetArray_init),
+    (void*)(&cuTexRefGetMipmappedArray_init),
+    (void*)(&cuTexRefGetAddressMode_init),
+    (void*)(&cuTexRefGetFilterMode_init),
+    (void*)(&cuTexRefGetFormat_init),
+    (void*)(&cuTexRefGetMipmapFilterMode_init),
+    (void*)(&cuTexRefGetMipmapLevelBias_init),
+    (void*)(&cuTexRefGetMipmapLevelClamp_init),
+    (void*)(&cuTexRefGetMaxAnisotropy_init),
+    (void*)(&cuTexRefGetBorderColor_init),
+    (void*)(&cuTexRefGetFlags_init),
+    (void*)(&cuTexRefCreate_init),
+    (void*)(&cuTexRefDestroy_init),
+    (void*)(&cuSurfRefSetArray_init),
+    (void*)(&cuSurfRefGetArray_init),
+    (void*)(&cuTexObjectCreate_init),
+    (void*)(&cuTexObjectDestroy_init),
+    (void*)(&cuTexObjectGetResourceDesc_init),
+    (void*)(&cuTexObjectGetTextureDesc_init),
+    (void*)(&cuTexObjectGetResourceViewDesc_init),
+    (void*)(&cuSurfObjectCreate_init),
+    (void*)(&cuSurfObjectDestroy_init),
+    (void*)(&cuSurfObjectGetResourceDesc_init),
+    (void*)(&cuDeviceCanAccessPeer_init),
+    (void*)(&cuCtxEnablePeerAccess_init),
+    (void*)(&cuCtxDisablePeerAccess_init),
+    (void*)(&cuDeviceGetP2PAttribute_init),
+    (void*)(&cuGraphicsUnregisterResource_init),
+    (void*)(&cuGraphicsSubResourceGetMappedArray_init),
+    (void*)(&cuGraphicsResourceGetMappedMipmappedArray_init),
+    (void*)(&cuGraphicsResourceGetMappedPointer_v2_init),
+    (void*)(&cuGraphicsResourceSetMapFlags_v2_init),
+    (void*)(&cuGraphicsMapResources_ptsz_init),
+    (void*)(&cuGraphicsUnmapResources_ptsz_init),
+    (void*)(&cuGetExportTable_init),
+    (void*)(&cuFuncGetModule_init),
+    (void*)(&cuMemHostRegister_init),
+    (void*)(&cuGraphicsResourceSetMapFlags_init),
+    (void*)(&cuLinkCreate_init),
+    (void*)(&cuLinkAddData_init),
+    (void*)(&cuLinkAddFile_init),
+    (void*)(&cuTexRefSetAddress2D_v2_init),
+    (void*)(&cuDeviceTotalMem_init),
+    (void*)(&cuCtxCreate_init),
+    (void*)(&cuModuleGetGlobal_init),
+    (void*)(&cuMemGetInfo_init),
+    (void*)(&cuMemAlloc_init),
+    (void*)(&cuMemAllocPitch_init),
+    (void*)(&cuMemFree_init),
+    (void*)(&cuMemGetAddressRange_init),
+    (void*)(&cuMemAllocHost_init),
+    (void*)(&cuMemHostGetDevicePointer_init),
+    (void*)(&cuMemcpyHtoD_init),
+    (void*)(&cuMemcpyDtoH_init),
+    (void*)(&cuMemcpyDtoD_init),
+    (void*)(&cuMemcpyDtoA_init),
+    (void*)(&cuMemcpyAtoD_init),
+    (void*)(&cuMemcpyHtoA_init),
+    (void*)(&cuMemcpyAtoH_init),
+    (void*)(&cuMemcpyAtoA_init),
+    (void*)(&cuMemcpyHtoAAsync_init),
+    (void*)(&cuMemcpyAtoHAsync_init),
+    (void*)(&cuMemcpy2D_init),
+    (void*)(&cuMemcpy2DUnaligned_init),
+    (void*)(&cuMemcpy3D_init),
+    (void*)(&cuMemcpyHtoDAsync_init),
+    (void*)(&cuMemcpyDtoHAsync_init),
+    (void*)(&cuMemcpyDtoDAsync_init),
+    (void*)(&cuMemcpy2DAsync_init),
+    (void*)(&cuMemcpy3DAsync_init),
+    (void*)(&cuMemsetD8_init),
+    (void*)(&cuMemsetD16_init),
+    (void*)(&cuMemsetD32_init),
+    (void*)(&cuMemsetD2D8_init),
+    (void*)(&cuMemsetD2D16_init),
+    (void*)(&cuMemsetD2D32_init),
+    (void*)(&cuArrayCreate_init),
+    (void*)(&cuArrayGetDescriptor_init),
+    (void*)(&cuArray3DCreate_init),
+    (void*)(&cuArray3DGetDescriptor_init),
+    (void*)(&cuTexRefSetAddress_init),
+    (void*)(&cuTexRefSetAddress2D_init),
+    (void*)(&cuTexRefGetAddress_init),
+    (void*)(&cuGraphicsResourceGetMappedPointer_init),
+    (void*)(&cuCtxDestroy_init),
+    (void*)(&cuCtxPopCurrent_init),
+    (void*)(&cuCtxPushCurrent_init),
+    (void*)(&cuStreamDestroy_init),
+    (void*)(&cuEventDestroy_init),
+    (void*)(&cuDevicePrimaryCtxRelease_init),
+    (void*)(&cuDevicePrimaryCtxReset_init),
+    (void*)(&cuDevicePrimaryCtxSetFlags_init),
+    (void*)(&cuMemcpyHtoD_v2_init),
+    (void*)(&cuMemcpyDtoH_v2_init),
+    (void*)(&cuMemcpyDtoD_v2_init),
+    (void*)(&cuMemcpyDtoA_v2_init),
+    (void*)(&cuMemcpyAtoD_v2_init),
+    (void*)(&cuMemcpyHtoA_v2_init),
+    (void*)(&cuMemcpyAtoH_v2_init),
+    (void*)(&cuMemcpyAtoA_v2_init),
+    (void*)(&cuMemcpyHtoAAsync_v2_init),
+    (void*)(&cuMemcpyAtoHAsync_v2_init),
+    (void*)(&cuMemcpy2D_v2_init),
+    (void*)(&cuMemcpy2DUnaligned_v2_init),
+    (void*)(&cuMemcpy3D_v2_init),
+    (void*)(&cuMemcpyHtoDAsync_v2_init),
+    (void*)(&cuMemcpyDtoHAsync_v2_init),
+    (void*)(&cuMemcpyDtoDAsync_v2_init),
+    (void*)(&cuMemcpy2DAsync_v2_init),
+    (void*)(&cuMemcpy3DAsync_v2_init),
+    (void*)(&cuMemsetD8_v2_init),
+    (void*)(&cuMemsetD16_v2_init),
+    (void*)(&cuMemsetD32_v2_init),
+    (void*)(&cuMemsetD2D8_v2_init),
+    (void*)(&cuMemsetD2D16_v2_init),
+    (void*)(&cuMemsetD2D32_v2_init),
+    (void*)(&cuMemcpy_init),
+    (void*)(&cuMemcpyAsync_init),
+    (void*)(&cuMemcpyPeer_init),
+    (void*)(&cuMemcpyPeerAsync_init),
+    (void*)(&cuMemcpy3DPeer_init),
+    (void*)(&cuMemcpy3DPeerAsync_init),
+    (void*)(&cuMemsetD8Async_init),
+    (void*)(&cuMemsetD16Async_init),
+    (void*)(&cuMemsetD32Async_init),
+    (void*)(&cuMemsetD2D8Async_init),
+    (void*)(&cuMemsetD2D16Async_init),
+    (void*)(&cuMemsetD2D32Async_init),
+    (void*)(&cuStreamGetPriority_init),
+    (void*)(&cuStreamGetFlags_init),
+    (void*)(&cuStreamGetCtx_init),
+    (void*)(&cuStreamWaitEvent_init),
+    (void*)(&cuStreamAddCallback_init),
+    (void*)(&cuStreamAttachMemAsync_init),
+    (void*)(&cuStreamQuery_init),
+    (void*)(&cuStreamSynchronize_init),
+    (void*)(&cuEventRecord_init),
+    (void*)(&cuEventRecordWithFlags_init),
+    (void*)(&cuLaunchKernel_init),
+    (void*)(&cuLaunchHostFunc_init),
+    (void*)(&cuGraphicsMapResources_init),
+    (void*)(&cuGraphicsUnmapResources_init),
+    (void*)(&cuStreamWriteValue32_init),
+    (void*)(&cuStreamWaitValue32_init),
+    (void*)(&cuStreamWriteValue64_init),
+    (void*)(&cuStreamWaitValue64_init),
+    (void*)(&cuStreamBatchMemOp_init),
+    (void*)(&cuMemPrefetchAsync_init),
+    (void*)(&cuLaunchCooperativeKernel_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_init),
+    (void*)(&cuStreamBeginCapture_init),
+    (void*)(&cuStreamBeginCapture_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_init),
+    (void*)(&cuStreamEndCapture_init),
+    (void*)(&cuStreamIsCapturing_init),
+    (void*)(&cuStreamGetCaptureInfo_init),
+    (void*)(&cuGraphUpload_init),
+    (void*)(&cuGraphLaunch_init),
+    (void*)(&cuStreamCopyAttributes_init),
+    (void*)(&cuStreamGetAttribute_init),
+    (void*)(&cuStreamSetAttribute_init),
+    (void*)(&cuIpcOpenMemHandle_init),
+    (void*)(&cuGraphInstantiate_init),
+    (void*)(&cuMemMapArrayAsync_init),
+    (void*)(&cuProfilerInitialize_init),
+    (void*)(&cuProfilerStart_init),
+    (void*)(&cuProfilerStop_init)};
+static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
+    (void*)(&cuGetErrorName_error),
+    (void*)(&cuInit_error),
+    (void*)(&cuDriverGetVersion_error),
+    (void*)(&cuDeviceGet_error),
+    (void*)(&cuDeviceGetCount_error),
+    (void*)(&cuDeviceGetName_error),
+    (void*)(&cuDeviceGetUuid_error),
+    (void*)(&cuDeviceGetLuid_error),
+    (void*)(&cuDeviceTotalMem_v2_error),
+    (void*)(&cuDeviceGetTexture1DLinearMaxWidth_error),
+    (void*)(&cuDeviceGetAttribute_error),
+    (void*)(&cuDeviceGetNvSciSyncAttributes_error),
+    (void*)(&cuDeviceGetProperties_error),
+    (void*)(&cuDeviceComputeCapability_error),
+    (void*)(&cuDevicePrimaryCtxRetain_error),
+    (void*)(&cuDevicePrimaryCtxRelease_v2_error),
+    (void*)(&cuDevicePrimaryCtxSetFlags_v2_error),
+    (void*)(&cuDevicePrimaryCtxGetState_error),
+    (void*)(&cuDevicePrimaryCtxReset_v2_error),
+    (void*)(&cuCtxCreate_v2_error),
+    (void*)(&cuCtxDestroy_v2_error),
+    (void*)(&cuCtxPushCurrent_v2_error),
+    (void*)(&cuCtxPopCurrent_v2_error),
+    (void*)(&cuCtxSetCurrent_error),
+    (void*)(&cuCtxGetCurrent_error),
+    (void*)(&cuCtxGetDevice_error),
+    (void*)(&cuCtxGetFlags_error),
+    (void*)(&cuCtxSynchronize_error),
+    (void*)(&cuCtxSetLimit_error),
+    (void*)(&cuCtxGetLimit_error),
+    (void*)(&cuCtxGetCacheConfig_error),
+    (void*)(&cuCtxSetCacheConfig_error),
+    (void*)(&cuCtxGetSharedMemConfig_error),
+    (void*)(&cuCtxSetSharedMemConfig_error),
+    (void*)(&cuCtxGetApiVersion_error),
+    (void*)(&cuCtxGetStreamPriorityRange_error),
+    (void*)(&cuCtxResetPersistingL2Cache_error),
+    (void*)(&cuCtxAttach_error),
+    (void*)(&cuCtxDetach_error),
+    (void*)(&cuModuleLoad_error),
+    (void*)(&cuModuleLoadData_error),
+    (void*)(&cuModuleLoadDataEx_error),
+    (void*)(&cuModuleLoadFatBinary_error),
+    (void*)(&cuModuleUnload_error),
+    (void*)(&cuModuleGetFunction_error),
+    (void*)(&cuModuleGetGlobal_v2_error),
+    (void*)(&cuModuleGetTexRef_error),
+    (void*)(&cuModuleGetSurfRef_error),
+    (void*)(&cuLinkCreate_v2_error),
+    (void*)(&cuLinkAddData_v2_error),
+    (void*)(&cuLinkAddFile_v2_error),
+    (void*)(&cuLinkComplete_error),
+    (void*)(&cuLinkDestroy_error),
+    (void*)(&cuMemGetInfo_v2_error),
+    (void*)(&cuMemAlloc_v2_error),
+    (void*)(&cuMemAllocPitch_v2_error),
+    (void*)(&cuMemFree_v2_error),
+    (void*)(&cuMemGetAddressRange_v2_error),
+    (void*)(&cuMemAllocHost_v2_error),
+    (void*)(&cuMemFreeHost_error),
+    (void*)(&cuMemHostAlloc_error),
+    (void*)(&cuMemHostGetDevicePointer_v2_error),
+    (void*)(&cuMemHostGetFlags_error),
+    (void*)(&cuMemAllocManaged_error),
+    (void*)(&cuDeviceGetByPCIBusId_error),
+    (void*)(&cuDeviceGetPCIBusId_error),
+    (void*)(&cuIpcGetEventHandle_error),
+    (void*)(&cuIpcOpenEventHandle_error),
+    (void*)(&cuIpcGetMemHandle_error),
+    (void*)(&cuIpcOpenMemHandle_v2_error),
+    (void*)(&cuIpcCloseMemHandle_error),
+    (void*)(&cuMemHostRegister_v2_error),
+    (void*)(&cuMemHostUnregister_error),
+    (void*)(&cuMemcpy_ptds_error),
+    (void*)(&cuMemcpyPeer_ptds_error),
+    (void*)(&cuMemcpyHtoD_v2_ptds_error),
+    (void*)(&cuMemcpyDtoH_v2_ptds_error),
+    (void*)(&cuMemcpyDtoD_v2_ptds_error),
+    (void*)(&cuMemcpyDtoA_v2_ptds_error),
+    (void*)(&cuMemcpyAtoD_v2_ptds_error),
+    (void*)(&cuMemcpyHtoA_v2_ptds_error),
+    (void*)(&cuMemcpyAtoH_v2_ptds_error),
+    (void*)(&cuMemcpyAtoA_v2_ptds_error),
+    (void*)(&cuMemcpy2D_v2_ptds_error),
+    (void*)(&cuMemcpy2DUnaligned_v2_ptds_error),
+    (void*)(&cuMemcpy3D_v2_ptds_error),
+    (void*)(&cuMemcpy3DPeer_ptds_error),
+    (void*)(&cuMemcpyAsync_ptsz_error),
+    (void*)(&cuMemcpyPeerAsync_ptsz_error),
+    (void*)(&cuMemcpyHtoDAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyDtoHAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyDtoDAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyHtoAAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyAtoHAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy2DAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy3DAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy3DPeerAsync_ptsz_error),
+    (void*)(&cuMemsetD8_v2_ptds_error),
+    (void*)(&cuMemsetD16_v2_ptds_error),
+    (void*)(&cuMemsetD32_v2_ptds_error),
+    (void*)(&cuMemsetD2D8_v2_ptds_error),
+    (void*)(&cuMemsetD2D16_v2_ptds_error),
+    (void*)(&cuMemsetD2D32_v2_ptds_error),
+    (void*)(&cuMemsetD8Async_ptsz_error),
+    (void*)(&cuMemsetD16Async_ptsz_error),
+    (void*)(&cuMemsetD32Async_ptsz_error),
+    (void*)(&cuMemsetD2D8Async_ptsz_error),
+    (void*)(&cuMemsetD2D16Async_ptsz_error),
+    (void*)(&cuMemsetD2D32Async_ptsz_error),
+    (void*)(&cuArrayCreate_v2_error),
+    (void*)(&cuArrayGetDescriptor_v2_error),
+    (void*)(&cuArrayGetSparseProperties_error),
+    (void*)(&cuMipmappedArrayGetSparseProperties_error),
+    (void*)(&cuArrayDestroy_error),
+    (void*)(&cuArray3DCreate_v2_error),
+    (void*)(&cuArray3DGetDescriptor_v2_error),
+    (void*)(&cuMipmappedArrayCreate_error),
+    (void*)(&cuMipmappedArrayGetLevel_error),
+    (void*)(&cuMipmappedArrayDestroy_error),
+    (void*)(&cuMemAddressReserve_error),
+    (void*)(&cuMemAddressFree_error),
+    (void*)(&cuMemCreate_error),
+    (void*)(&cuMemRelease_error),
+    (void*)(&cuMemMap_error),
+    (void*)(&cuMemMapArrayAsync_ptsz_error),
+    (void*)(&cuMemUnmap_error),
+    (void*)(&cuMemSetAccess_error),
+    (void*)(&cuMemGetAccess_error),
+    (void*)(&cuMemExportToShareableHandle_error),
+    (void*)(&cuMemImportFromShareableHandle_error),
+    (void*)(&cuMemGetAllocationGranularity_error),
+    (void*)(&cuMemGetAllocationPropertiesFromHandle_error),
+    (void*)(&cuMemRetainAllocationHandle_error),
+    (void*)(&cuPointerGetAttribute_error),
+    (void*)(&cuMemPrefetchAsync_ptsz_error),
+    (void*)(&cuMemAdvise_error),
+    (void*)(&cuMemRangeGetAttribute_error),
+    (void*)(&cuMemRangeGetAttributes_error),
+    (void*)(&cuPointerSetAttribute_error),
+    (void*)(&cuPointerGetAttributes_error),
+    (void*)(&cuStreamCreate_error),
+    (void*)(&cuStreamCreateWithPriority_error),
+    (void*)(&cuStreamGetPriority_ptsz_error),
+    (void*)(&cuStreamGetFlags_ptsz_error),
+    (void*)(&cuStreamGetCtx_ptsz_error),
+    (void*)(&cuStreamWaitEvent_ptsz_error),
+    (void*)(&cuStreamAddCallback_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_error),
+    (void*)(&cuThreadExchangeStreamCaptureMode_error),
+    (void*)(&cuStreamEndCapture_ptsz_error),
+    (void*)(&cuStreamIsCapturing_ptsz_error),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_error),
+    (void*)(&cuStreamAttachMemAsync_ptsz_error),
+    (void*)(&cuStreamQuery_ptsz_error),
+    (void*)(&cuStreamSynchronize_ptsz_error),
+    (void*)(&cuStreamDestroy_v2_error),
+    (void*)(&cuStreamCopyAttributes_ptsz_error),
+    (void*)(&cuStreamGetAttribute_ptsz_error),
+    (void*)(&cuStreamSetAttribute_ptsz_error),
+    (void*)(&cuEventCreate_error),
+    (void*)(&cuEventRecord_ptsz_error),
+    (void*)(&cuEventRecordWithFlags_ptsz_error),
+    (void*)(&cuEventQuery_error),
+    (void*)(&cuEventSynchronize_error),
+    (void*)(&cuEventDestroy_v2_error),
+    (void*)(&cuEventElapsedTime_error),
+    (void*)(&cuImportExternalMemory_error),
+    (void*)(&cuExternalMemoryGetMappedBuffer_error),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_error),
+    (void*)(&cuDestroyExternalMemory_error),
+    (void*)(&cuImportExternalSemaphore_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuDestroyExternalSemaphore_error),
+    (void*)(&cuStreamWaitValue32_ptsz_error),
+    (void*)(&cuStreamWaitValue64_ptsz_error),
+    (void*)(&cuStreamWriteValue32_ptsz_error),
+    (void*)(&cuStreamWriteValue64_ptsz_error),
+    (void*)(&cuStreamBatchMemOp_ptsz_error),
+    (void*)(&cuFuncGetAttribute_error),
+    (void*)(&cuFuncSetAttribute_error),
+    (void*)(&cuFuncSetCacheConfig_error),
+    (void*)(&cuFuncSetSharedMemConfig_error),
+    (void*)(&cuLaunchKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_error),
+    (void*)(&cuLaunchHostFunc_ptsz_error),
+    (void*)(&cuFuncSetBlockShape_error),
+    (void*)(&cuFuncSetSharedSize_error),
+    (void*)(&cuParamSetSize_error),
+    (void*)(&cuParamSeti_error),
+    (void*)(&cuParamSetf_error),
+    (void*)(&cuParamSetv_error),
+    (void*)(&cuLaunch_error),
+    (void*)(&cuLaunchGrid_error),
+    (void*)(&cuLaunchGridAsync_error),
+    (void*)(&cuParamSetTexRef_error),
+    (void*)(&cuGraphCreate_error),
+    (void*)(&cuGraphAddKernelNode_error),
+    (void*)(&cuGraphKernelNodeGetParams_error),
+    (void*)(&cuGraphKernelNodeSetParams_error),
+    (void*)(&cuGraphAddMemcpyNode_error),
+    (void*)(&cuGraphMemcpyNodeGetParams_error),
+    (void*)(&cuGraphMemcpyNodeSetParams_error),
+    (void*)(&cuGraphAddMemsetNode_error),
+    (void*)(&cuGraphMemsetNodeGetParams_error),
+    (void*)(&cuGraphMemsetNodeSetParams_error),
+    (void*)(&cuGraphAddHostNode_error),
+    (void*)(&cuGraphHostNodeGetParams_error),
+    (void*)(&cuGraphHostNodeSetParams_error),
+    (void*)(&cuGraphAddChildGraphNode_error),
+    (void*)(&cuGraphChildGraphNodeGetGraph_error),
+    (void*)(&cuGraphAddEmptyNode_error),
+    (void*)(&cuGraphAddEventRecordNode_error),
+    (void*)(&cuGraphEventRecordNodeGetEvent_error),
+    (void*)(&cuGraphEventRecordNodeSetEvent_error),
+    (void*)(&cuGraphAddEventWaitNode_error),
+    (void*)(&cuGraphEventWaitNodeGetEvent_error),
+    (void*)(&cuGraphEventWaitNodeSetEvent_error),
+    (void*)(&cuGraphClone_error),
+    (void*)(&cuGraphNodeFindInClone_error),
+    (void*)(&cuGraphNodeGetType_error),
+    (void*)(&cuGraphGetNodes_error),
+    (void*)(&cuGraphGetRootNodes_error),
+    (void*)(&cuGraphGetEdges_error),
+    (void*)(&cuGraphNodeGetDependencies_error),
+    (void*)(&cuGraphNodeGetDependentNodes_error),
+    (void*)(&cuGraphAddDependencies_error),
+    (void*)(&cuGraphRemoveDependencies_error),
+    (void*)(&cuGraphDestroyNode_error),
+    (void*)(&cuGraphInstantiate_v2_error),
+    (void*)(&cuGraphExecKernelNodeSetParams_error),
+    (void*)(&cuGraphExecMemcpyNodeSetParams_error),
+    (void*)(&cuGraphExecMemsetNodeSetParams_error),
+    (void*)(&cuGraphExecHostNodeSetParams_error),
+    (void*)(&cuGraphExecChildGraphNodeSetParams_error),
+    (void*)(&cuGraphExecEventRecordNodeSetEvent_error),
+    (void*)(&cuGraphExecEventWaitNodeSetEvent_error),
+    (void*)(&cuGraphUpload_ptsz_error),
+    (void*)(&cuGraphLaunch_ptsz_error),
+    (void*)(&cuGraphExecDestroy_error),
+    (void*)(&cuGraphDestroy_error),
+    (void*)(&cuGraphExecUpdate_error),
+    (void*)(&cuGraphKernelNodeCopyAttributes_error),
+    (void*)(&cuGraphKernelNodeGetAttribute_error),
+    (void*)(&cuGraphKernelNodeSetAttribute_error),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_error),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error),
+    (void*)(&cuOccupancyMaxPotentialBlockSize_error),
+    (void*)(&cuOccupancyMaxPotentialBlockSizeWithFlags_error),
+    (void*)(&cuOccupancyAvailableDynamicSMemPerBlock_error),
+    (void*)(&cuTexRefSetArray_error),
+    (void*)(&cuTexRefSetMipmappedArray_error),
+    (void*)(&cuTexRefSetAddress_v2_error),
+    (void*)(&cuTexRefSetAddress2D_v3_error),
+    (void*)(&cuTexRefSetFormat_error),
+    (void*)(&cuTexRefSetAddressMode_error),
+    (void*)(&cuTexRefSetFilterMode_error),
+    (void*)(&cuTexRefSetMipmapFilterMode_error),
+    (void*)(&cuTexRefSetMipmapLevelBias_error),
+    (void*)(&cuTexRefSetMipmapLevelClamp_error),
+    (void*)(&cuTexRefSetMaxAnisotropy_error),
+    (void*)(&cuTexRefSetBorderColor_error),
+    (void*)(&cuTexRefSetFlags_error),
+    (void*)(&cuTexRefGetAddress_v2_error),
+    (void*)(&cuTexRefGetArray_error),
+    (void*)(&cuTexRefGetMipmappedArray_error),
+    (void*)(&cuTexRefGetAddressMode_error),
+    (void*)(&cuTexRefGetFilterMode_error),
+    (void*)(&cuTexRefGetFormat_error),
+    (void*)(&cuTexRefGetMipmapFilterMode_error),
+    (void*)(&cuTexRefGetMipmapLevelBias_error),
+    (void*)(&cuTexRefGetMipmapLevelClamp_error),
+    (void*)(&cuTexRefGetMaxAnisotropy_error),
+    (void*)(&cuTexRefGetBorderColor_error),
+    (void*)(&cuTexRefGetFlags_error),
+    (void*)(&cuTexRefCreate_error),
+    (void*)(&cuTexRefDestroy_error),
+    (void*)(&cuSurfRefSetArray_error),
+    (void*)(&cuSurfRefGetArray_error),
+    (void*)(&cuTexObjectCreate_error),
+    (void*)(&cuTexObjectDestroy_error),
+    (void*)(&cuTexObjectGetResourceDesc_error),
+    (void*)(&cuTexObjectGetTextureDesc_error),
+    (void*)(&cuTexObjectGetResourceViewDesc_error),
+    (void*)(&cuSurfObjectCreate_error),
+    (void*)(&cuSurfObjectDestroy_error),
+    (void*)(&cuSurfObjectGetResourceDesc_error),
+    (void*)(&cuDeviceCanAccessPeer_error),
+    (void*)(&cuCtxEnablePeerAccess_error),
+    (void*)(&cuCtxDisablePeerAccess_error),
+    (void*)(&cuDeviceGetP2PAttribute_error),
+    (void*)(&cuGraphicsUnregisterResource_error),
+    (void*)(&cuGraphicsSubResourceGetMappedArray_error),
+    (void*)(&cuGraphicsResourceGetMappedMipmappedArray_error),
+    (void*)(&cuGraphicsResourceGetMappedPointer_v2_error),
+    (void*)(&cuGraphicsResourceSetMapFlags_v2_error),
+    (void*)(&cuGraphicsMapResources_ptsz_error),
+    (void*)(&cuGraphicsUnmapResources_ptsz_error),
+    (void*)(&cuGetExportTable_error),
+    (void*)(&cuFuncGetModule_error),
+    (void*)(&cuMemHostRegister_error),
+    (void*)(&cuGraphicsResourceSetMapFlags_error),
+    (void*)(&cuLinkCreate_error),
+    (void*)(&cuLinkAddData_error),
+    (void*)(&cuLinkAddFile_error),
+    (void*)(&cuTexRefSetAddress2D_v2_error),
+    (void*)(&cuDeviceTotalMem_error),
+    (void*)(&cuCtxCreate_error),
+    (void*)(&cuModuleGetGlobal_error),
+    (void*)(&cuMemGetInfo_error),
+    (void*)(&cuMemAlloc_error),
+    (void*)(&cuMemAllocPitch_error),
+    (void*)(&cuMemFree_error),
+    (void*)(&cuMemGetAddressRange_error),
+    (void*)(&cuMemAllocHost_error),
+    (void*)(&cuMemHostGetDevicePointer_error),
+    (void*)(&cuMemcpyHtoD_error),
+    (void*)(&cuMemcpyDtoH_error),
+    (void*)(&cuMemcpyDtoD_error),
+    (void*)(&cuMemcpyDtoA_error),
+    (void*)(&cuMemcpyAtoD_error),
+    (void*)(&cuMemcpyHtoA_error),
+    (void*)(&cuMemcpyAtoH_error),
+    (void*)(&cuMemcpyAtoA_error),
+    (void*)(&cuMemcpyHtoAAsync_error),
+    (void*)(&cuMemcpyAtoHAsync_error),
+    (void*)(&cuMemcpy2D_error),
+    (void*)(&cuMemcpy2DUnaligned_error),
+    (void*)(&cuMemcpy3D_error),
+    (void*)(&cuMemcpyHtoDAsync_error),
+    (void*)(&cuMemcpyDtoHAsync_error),
+    (void*)(&cuMemcpyDtoDAsync_error),
+    (void*)(&cuMemcpy2DAsync_error),
+    (void*)(&cuMemcpy3DAsync_error),
+    (void*)(&cuMemsetD8_error),
+    (void*)(&cuMemsetD16_error),
+    (void*)(&cuMemsetD32_error),
+    (void*)(&cuMemsetD2D8_error),
+    (void*)(&cuMemsetD2D16_error),
+    (void*)(&cuMemsetD2D32_error),
+    (void*)(&cuArrayCreate_error),
+    (void*)(&cuArrayGetDescriptor_error),
+    (void*)(&cuArray3DCreate_error),
+    (void*)(&cuArray3DGetDescriptor_error),
+    (void*)(&cuTexRefSetAddress_error),
+    (void*)(&cuTexRefSetAddress2D_error),
+    (void*)(&cuTexRefGetAddress_error),
+    (void*)(&cuGraphicsResourceGetMappedPointer_error),
+    (void*)(&cuCtxDestroy_error),
+    (void*)(&cuCtxPopCurrent_error),
+    (void*)(&cuCtxPushCurrent_error),
+    (void*)(&cuStreamDestroy_error),
+    (void*)(&cuEventDestroy_error),
+    (void*)(&cuDevicePrimaryCtxRelease_error),
+    (void*)(&cuDevicePrimaryCtxReset_error),
+    (void*)(&cuDevicePrimaryCtxSetFlags_error),
+    (void*)(&cuMemcpyHtoD_v2_error),
+    (void*)(&cuMemcpyDtoH_v2_error),
+    (void*)(&cuMemcpyDtoD_v2_error),
+    (void*)(&cuMemcpyDtoA_v2_error),
+    (void*)(&cuMemcpyAtoD_v2_error),
+    (void*)(&cuMemcpyHtoA_v2_error),
+    (void*)(&cuMemcpyAtoH_v2_error),
+    (void*)(&cuMemcpyAtoA_v2_error),
+    (void*)(&cuMemcpyHtoAAsync_v2_error),
+    (void*)(&cuMemcpyAtoHAsync_v2_error),
+    (void*)(&cuMemcpy2D_v2_error),
+    (void*)(&cuMemcpy2DUnaligned_v2_error),
+    (void*)(&cuMemcpy3D_v2_error),
+    (void*)(&cuMemcpyHtoDAsync_v2_error),
+    (void*)(&cuMemcpyDtoHAsync_v2_error),
+    (void*)(&cuMemcpyDtoDAsync_v2_error),
+    (void*)(&cuMemcpy2DAsync_v2_error),
+    (void*)(&cuMemcpy3DAsync_v2_error),
+    (void*)(&cuMemsetD8_v2_error),
+    (void*)(&cuMemsetD16_v2_error),
+    (void*)(&cuMemsetD32_v2_error),
+    (void*)(&cuMemsetD2D8_v2_error),
+    (void*)(&cuMemsetD2D16_v2_error),
+    (void*)(&cuMemsetD2D32_v2_error),
+    (void*)(&cuMemcpy_error),
+    (void*)(&cuMemcpyAsync_error),
+    (void*)(&cuMemcpyPeer_error),
+    (void*)(&cuMemcpyPeerAsync_error),
+    (void*)(&cuMemcpy3DPeer_error),
+    (void*)(&cuMemcpy3DPeerAsync_error),
+    (void*)(&cuMemsetD8Async_error),
+    (void*)(&cuMemsetD16Async_error),
+    (void*)(&cuMemsetD32Async_error),
+    (void*)(&cuMemsetD2D8Async_error),
+    (void*)(&cuMemsetD2D16Async_error),
+    (void*)(&cuMemsetD2D32Async_error),
+    (void*)(&cuStreamGetPriority_error),
+    (void*)(&cuStreamGetFlags_error),
+    (void*)(&cuStreamGetCtx_error),
+    (void*)(&cuStreamWaitEvent_error),
+    (void*)(&cuStreamAddCallback_error),
+    (void*)(&cuStreamAttachMemAsync_error),
+    (void*)(&cuStreamQuery_error),
+    (void*)(&cuStreamSynchronize_error),
+    (void*)(&cuEventRecord_error),
+    (void*)(&cuEventRecordWithFlags_error),
+    (void*)(&cuLaunchKernel_error),
+    (void*)(&cuLaunchHostFunc_error),
+    (void*)(&cuGraphicsMapResources_error),
+    (void*)(&cuGraphicsUnmapResources_error),
+    (void*)(&cuStreamWriteValue32_error),
+    (void*)(&cuStreamWaitValue32_error),
+    (void*)(&cuStreamWriteValue64_error),
+    (void*)(&cuStreamWaitValue64_error),
+    (void*)(&cuStreamBatchMemOp_error),
+    (void*)(&cuMemPrefetchAsync_error),
+    (void*)(&cuLaunchCooperativeKernel_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_error),
+    (void*)(&cuStreamBeginCapture_error),
+    (void*)(&cuStreamBeginCapture_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_error),
+    (void*)(&cuStreamEndCapture_error),
+    (void*)(&cuStreamIsCapturing_error),
+    (void*)(&cuStreamGetCaptureInfo_error),
+    (void*)(&cuGraphUpload_error),
+    (void*)(&cuGraphLaunch_error),
+    (void*)(&cuStreamCopyAttributes_error),
+    (void*)(&cuStreamGetAttribute_error),
+    (void*)(&cuStreamSetAttribute_error),
+    (void*)(&cuIpcOpenMemHandle_error),
+    (void*)(&cuGraphInstantiate_error),
+    (void*)(&cuMemMapArrayAsync_error),
+    (void*)(&cuProfilerInitialize_error),
+    (void*)(&cuProfilerStart_error),
+    (void*)(&cuProfilerStop_error)};
+static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
+    "cuGetErrorName",
+    "cuInit",
+    "cuDriverGetVersion",
+    "cuDeviceGet",
+    "cuDeviceGetCount",
+    "cuDeviceGetName",
+    "cuDeviceGetUuid",
+    "cuDeviceGetLuid",
+    "cuDeviceTotalMem_v2",
+    "cuDeviceGetTexture1DLinearMaxWidth",
+    "cuDeviceGetAttribute",
+    "cuDeviceGetNvSciSyncAttributes",
+    "cuDeviceGetProperties",
+    "cuDeviceComputeCapability",
+    "cuDevicePrimaryCtxRetain",
+    "cuDevicePrimaryCtxRelease_v2",
+    "cuDevicePrimaryCtxSetFlags_v2",
+    "cuDevicePrimaryCtxGetState",
+    "cuDevicePrimaryCtxReset_v2",
+    "cuCtxCreate_v2",
+    "cuCtxDestroy_v2",
+    "cuCtxPushCurrent_v2",
+    "cuCtxPopCurrent_v2",
+    "cuCtxSetCurrent",
+    "cuCtxGetCurrent",
+    "cuCtxGetDevice",
+    "cuCtxGetFlags",
+    "cuCtxSynchronize",
+    "cuCtxSetLimit",
+    "cuCtxGetLimit",
+    "cuCtxGetCacheConfig",
+    "cuCtxSetCacheConfig",
+    "cuCtxGetSharedMemConfig",
+    "cuCtxSetSharedMemConfig",
+    "cuCtxGetApiVersion",
+    "cuCtxGetStreamPriorityRange",
+    "cuCtxResetPersistingL2Cache",
+    "cuCtxAttach",
+    "cuCtxDetach",
+    "cuModuleLoad",
+    "cuModuleLoadData",
+    "cuModuleLoadDataEx",
+    "cuModuleLoadFatBinary",
+    "cuModuleUnload",
+    "cuModuleGetFunction",
+    "cuModuleGetGlobal_v2",
+    "cuModuleGetTexRef",
+    "cuModuleGetSurfRef",
+    "cuLinkCreate_v2",
+    "cuLinkAddData_v2",
+    "cuLinkAddFile_v2",
+    "cuLinkComplete",
+    "cuLinkDestroy",
+    "cuMemGetInfo_v2",
+    "cuMemAlloc_v2",
+    "cuMemAllocPitch_v2",
+    "cuMemFree_v2",
+    "cuMemGetAddressRange_v2",
+    "cuMemAllocHost_v2",
+    "cuMemFreeHost",
+    "cuMemHostAlloc",
+    "cuMemHostGetDevicePointer_v2",
+    "cuMemHostGetFlags",
+    "cuMemAllocManaged",
+    "cuDeviceGetByPCIBusId",
+    "cuDeviceGetPCIBusId",
+    "cuIpcGetEventHandle",
+    "cuIpcOpenEventHandle",
+    "cuIpcGetMemHandle",
+    "cuIpcOpenMemHandle_v2",
+    "cuIpcCloseMemHandle",
+    "cuMemHostRegister_v2",
+    "cuMemHostUnregister",
+    "cuMemcpy_ptds",
+    "cuMemcpyPeer_ptds",
+    "cuMemcpyHtoD_v2_ptds",
+    "cuMemcpyDtoH_v2_ptds",
+    "cuMemcpyDtoD_v2_ptds",
+    "cuMemcpyDtoA_v2_ptds",
+    "cuMemcpyAtoD_v2_ptds",
+    "cuMemcpyHtoA_v2_ptds",
+    "cuMemcpyAtoH_v2_ptds",
+    "cuMemcpyAtoA_v2_ptds",
+    "cuMemcpy2D_v2_ptds",
+    "cuMemcpy2DUnaligned_v2_ptds",
+    "cuMemcpy3D_v2_ptds",
+    "cuMemcpy3DPeer_ptds",
+    "cuMemcpyAsync_ptsz",
+    "cuMemcpyPeerAsync_ptsz",
+    "cuMemcpyHtoDAsync_v2_ptsz",
+    "cuMemcpyDtoHAsync_v2_ptsz",
+    "cuMemcpyDtoDAsync_v2_ptsz",
+    "cuMemcpyHtoAAsync_v2_ptsz",
+    "cuMemcpyAtoHAsync_v2_ptsz",
+    "cuMemcpy2DAsync_v2_ptsz",
+    "cuMemcpy3DAsync_v2_ptsz",
+    "cuMemcpy3DPeerAsync_ptsz",
+    "cuMemsetD8_v2_ptds",
+    "cuMemsetD16_v2_ptds",
+    "cuMemsetD32_v2_ptds",
+    "cuMemsetD2D8_v2_ptds",
+    "cuMemsetD2D16_v2_ptds",
+    "cuMemsetD2D32_v2_ptds",
+    "cuMemsetD8Async_ptsz",
+    "cuMemsetD16Async_ptsz",
+    "cuMemsetD32Async_ptsz",
+    "cuMemsetD2D8Async_ptsz",
+    "cuMemsetD2D16Async_ptsz",
+    "cuMemsetD2D32Async_ptsz",
+    "cuArrayCreate_v2",
+    "cuArrayGetDescriptor_v2",
+    "cuArrayGetSparseProperties",
+    "cuMipmappedArrayGetSparseProperties",
+    "cuArrayDestroy",
+    "cuArray3DCreate_v2",
+    "cuArray3DGetDescriptor_v2",
+    "cuMipmappedArrayCreate",
+    "cuMipmappedArrayGetLevel",
+    "cuMipmappedArrayDestroy",
+    "cuMemAddressReserve",
+    "cuMemAddressFree",
+    "cuMemCreate",
+    "cuMemRelease",
+    "cuMemMap",
+    "cuMemMapArrayAsync_ptsz",
+    "cuMemUnmap",
+    "cuMemSetAccess",
+    "cuMemGetAccess",
+    "cuMemExportToShareableHandle",
+    "cuMemImportFromShareableHandle",
+    "cuMemGetAllocationGranularity",
+    "cuMemGetAllocationPropertiesFromHandle",
+    "cuMemRetainAllocationHandle",
+    "cuPointerGetAttribute",
+    "cuMemPrefetchAsync_ptsz",
+    "cuMemAdvise",
+    "cuMemRangeGetAttribute",
+    "cuMemRangeGetAttributes",
+    "cuPointerSetAttribute",
+    "cuPointerGetAttributes",
+    "cuStreamCreate",
+    "cuStreamCreateWithPriority",
+    "cuStreamGetPriority_ptsz",
+    "cuStreamGetFlags_ptsz",
+    "cuStreamGetCtx_ptsz",
+    "cuStreamWaitEvent_ptsz",
+    "cuStreamAddCallback_ptsz",
+    "cuStreamBeginCapture_v2_ptsz",
+    "cuThreadExchangeStreamCaptureMode",
+    "cuStreamEndCapture_ptsz",
+    "cuStreamIsCapturing_ptsz",
+    "cuStreamGetCaptureInfo_ptsz",
+    "cuStreamAttachMemAsync_ptsz",
+    "cuStreamQuery_ptsz",
+    "cuStreamSynchronize_ptsz",
+    "cuStreamDestroy_v2",
+    "cuStreamCopyAttributes_ptsz",
+    "cuStreamGetAttribute_ptsz",
+    "cuStreamSetAttribute_ptsz",
+    "cuEventCreate",
+    "cuEventRecord_ptsz",
+    "cuEventRecordWithFlags_ptsz",
+    "cuEventQuery",
+    "cuEventSynchronize",
+    "cuEventDestroy_v2",
+    "cuEventElapsedTime",
+    "cuImportExternalMemory",
+    "cuExternalMemoryGetMappedBuffer",
+    "cuExternalMemoryGetMappedMipmappedArray",
+    "cuDestroyExternalMemory",
+    "cuImportExternalSemaphore",
+    "cuSignalExternalSemaphoresAsync_ptsz",
+    "cuWaitExternalSemaphoresAsync_ptsz",
+    "cuDestroyExternalSemaphore",
+    "cuStreamWaitValue32_ptsz",
+    "cuStreamWaitValue64_ptsz",
+    "cuStreamWriteValue32_ptsz",
+    "cuStreamWriteValue64_ptsz",
+    "cuStreamBatchMemOp_ptsz",
+    "cuFuncGetAttribute",
+    "cuFuncSetAttribute",
+    "cuFuncSetCacheConfig",
+    "cuFuncSetSharedMemConfig",
+    "cuLaunchKernel_ptsz",
+    "cuLaunchCooperativeKernel_ptsz",
+    "cuLaunchCooperativeKernelMultiDevice",
+    "cuLaunchHostFunc_ptsz",
+    "cuFuncSetBlockShape",
+    "cuFuncSetSharedSize",
+    "cuParamSetSize",
+    "cuParamSeti",
+    "cuParamSetf",
+    "cuParamSetv",
+    "cuLaunch",
+    "cuLaunchGrid",
+    "cuLaunchGridAsync",
+    "cuParamSetTexRef",
+    "cuGraphCreate",
+    "cuGraphAddKernelNode",
+    "cuGraphKernelNodeGetParams",
+    "cuGraphKernelNodeSetParams",
+    "cuGraphAddMemcpyNode",
+    "cuGraphMemcpyNodeGetParams",
+    "cuGraphMemcpyNodeSetParams",
+    "cuGraphAddMemsetNode",
+    "cuGraphMemsetNodeGetParams",
+    "cuGraphMemsetNodeSetParams",
+    "cuGraphAddHostNode",
+    "cuGraphHostNodeGetParams",
+    "cuGraphHostNodeSetParams",
+    "cuGraphAddChildGraphNode",
+    "cuGraphChildGraphNodeGetGraph",
+    "cuGraphAddEmptyNode",
+    "cuGraphAddEventRecordNode",
+    "cuGraphEventRecordNodeGetEvent",
+    "cuGraphEventRecordNodeSetEvent",
+    "cuGraphAddEventWaitNode",
+    "cuGraphEventWaitNodeGetEvent",
+    "cuGraphEventWaitNodeSetEvent",
+    "cuGraphClone",
+    "cuGraphNodeFindInClone",
+    "cuGraphNodeGetType",
+    "cuGraphGetNodes",
+    "cuGraphGetRootNodes",
+    "cuGraphGetEdges",
+    "cuGraphNodeGetDependencies",
+    "cuGraphNodeGetDependentNodes",
+    "cuGraphAddDependencies",
+    "cuGraphRemoveDependencies",
+    "cuGraphDestroyNode",
+    "cuGraphInstantiate_v2",
+    "cuGraphExecKernelNodeSetParams",
+    "cuGraphExecMemcpyNodeSetParams",
+    "cuGraphExecMemsetNodeSetParams",
+    "cuGraphExecHostNodeSetParams",
+    "cuGraphExecChildGraphNodeSetParams",
+    "cuGraphExecEventRecordNodeSetEvent",
+    "cuGraphExecEventWaitNodeSetEvent",
+    "cuGraphUpload_ptsz",
+    "cuGraphLaunch_ptsz",
+    "cuGraphExecDestroy",
+    "cuGraphDestroy",
+    "cuGraphExecUpdate",
+    "cuGraphKernelNodeCopyAttributes",
+    "cuGraphKernelNodeGetAttribute",
+    "cuGraphKernelNodeSetAttribute",
+    "cuOccupancyMaxActiveBlocksPerMultiprocessor",
+    "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags",
+    "cuOccupancyMaxPotentialBlockSize",
+    "cuOccupancyMaxPotentialBlockSizeWithFlags",
+    "cuOccupancyAvailableDynamicSMemPerBlock",
+    "cuTexRefSetArray",
+    "cuTexRefSetMipmappedArray",
+    "cuTexRefSetAddress_v2",
+    "cuTexRefSetAddress2D_v3",
+    "cuTexRefSetFormat",
+    "cuTexRefSetAddressMode",
+    "cuTexRefSetFilterMode",
+    "cuTexRefSetMipmapFilterMode",
+    "cuTexRefSetMipmapLevelBias",
+    "cuTexRefSetMipmapLevelClamp",
+    "cuTexRefSetMaxAnisotropy",
+    "cuTexRefSetBorderColor",
+    "cuTexRefSetFlags",
+    "cuTexRefGetAddress_v2",
+    "cuTexRefGetArray",
+    "cuTexRefGetMipmappedArray",
+    "cuTexRefGetAddressMode",
+    "cuTexRefGetFilterMode",
+    "cuTexRefGetFormat",
+    "cuTexRefGetMipmapFilterMode",
+    "cuTexRefGetMipmapLevelBias",
+    "cuTexRefGetMipmapLevelClamp",
+    "cuTexRefGetMaxAnisotropy",
+    "cuTexRefGetBorderColor",
+    "cuTexRefGetFlags",
+    "cuTexRefCreate",
+    "cuTexRefDestroy",
+    "cuSurfRefSetArray",
+    "cuSurfRefGetArray",
+    "cuTexObjectCreate",
+    "cuTexObjectDestroy",
+    "cuTexObjectGetResourceDesc",
+    "cuTexObjectGetTextureDesc",
+    "cuTexObjectGetResourceViewDesc",
+    "cuSurfObjectCreate",
+    "cuSurfObjectDestroy",
+    "cuSurfObjectGetResourceDesc",
+    "cuDeviceCanAccessPeer",
+    "cuCtxEnablePeerAccess",
+    "cuCtxDisablePeerAccess",
+    "cuDeviceGetP2PAttribute",
+    "cuGraphicsUnregisterResource",
+    "cuGraphicsSubResourceGetMappedArray",
+    "cuGraphicsResourceGetMappedMipmappedArray",
+    "cuGraphicsResourceGetMappedPointer_v2",
+    "cuGraphicsResourceSetMapFlags_v2",
+    "cuGraphicsMapResources_ptsz",
+    "cuGraphicsUnmapResources_ptsz",
+    "cuGetExportTable",
+    "cuFuncGetModule",
+    "cuMemHostRegister",
+    "cuGraphicsResourceSetMapFlags",
+    "cuLinkCreate",
+    "cuLinkAddData",
+    "cuLinkAddFile",
+    "cuTexRefSetAddress2D_v2",
+    "cuDeviceTotalMem",
+    "cuCtxCreate",
+    "cuModuleGetGlobal",
+    "cuMemGetInfo",
+    "cuMemAlloc",
+    "cuMemAllocPitch",
+    "cuMemFree",
+    "cuMemGetAddressRange",
+    "cuMemAllocHost",
+    "cuMemHostGetDevicePointer",
+    "cuMemcpyHtoD",
+    "cuMemcpyDtoH",
+    "cuMemcpyDtoD",
+    "cuMemcpyDtoA",
+    "cuMemcpyAtoD",
+    "cuMemcpyHtoA",
+    "cuMemcpyAtoH",
+    "cuMemcpyAtoA",
+    "cuMemcpyHtoAAsync",
+    "cuMemcpyAtoHAsync",
+    "cuMemcpy2D",
+    "cuMemcpy2DUnaligned",
+    "cuMemcpy3D",
+    "cuMemcpyHtoDAsync",
+    "cuMemcpyDtoHAsync",
+    "cuMemcpyDtoDAsync",
+    "cuMemcpy2DAsync",
+    "cuMemcpy3DAsync",
+    "cuMemsetD8",
+    "cuMemsetD16",
+    "cuMemsetD32",
+    "cuMemsetD2D8",
+    "cuMemsetD2D16",
+    "cuMemsetD2D32",
+    "cuArrayCreate",
+    "cuArrayGetDescriptor",
+    "cuArray3DCreate",
+    "cuArray3DGetDescriptor",
+    "cuTexRefSetAddress",
+    "cuTexRefSetAddress2D",
+    "cuTexRefGetAddress",
+    "cuGraphicsResourceGetMappedPointer",
+    "cuCtxDestroy",
+    "cuCtxPopCurrent",
+    "cuCtxPushCurrent",
+    "cuStreamDestroy",
+    "cuEventDestroy",
+    "cuDevicePrimaryCtxRelease",
+    "cuDevicePrimaryCtxReset",
+    "cuDevicePrimaryCtxSetFlags",
+    "cuMemcpyHtoD_v2",
+    "cuMemcpyDtoH_v2",
+    "cuMemcpyDtoD_v2",
+    "cuMemcpyDtoA_v2",
+    "cuMemcpyAtoD_v2",
+    "cuMemcpyHtoA_v2",
+    "cuMemcpyAtoH_v2",
+    "cuMemcpyAtoA_v2",
+    "cuMemcpyHtoAAsync_v2",
+    "cuMemcpyAtoHAsync_v2",
+    "cuMemcpy2D_v2",
+    "cuMemcpy2DUnaligned_v2",
+    "cuMemcpy3D_v2",
+    "cuMemcpyHtoDAsync_v2",
+    "cuMemcpyDtoHAsync_v2",
+    "cuMemcpyDtoDAsync_v2",
+    "cuMemcpy2DAsync_v2",
+    "cuMemcpy3DAsync_v2",
+    "cuMemsetD8_v2",
+    "cuMemsetD16_v2",
+    "cuMemsetD32_v2",
+    "cuMemsetD2D8_v2",
+    "cuMemsetD2D16_v2",
+    "cuMemsetD2D32_v2",
+    "cuMemcpy",
+    "cuMemcpyAsync",
+    "cuMemcpyPeer",
+    "cuMemcpyPeerAsync",
+    "cuMemcpy3DPeer",
+    "cuMemcpy3DPeerAsync",
+    "cuMemsetD8Async",
+    "cuMemsetD16Async",
+    "cuMemsetD32Async",
+    "cuMemsetD2D8Async",
+    "cuMemsetD2D16Async",
+    "cuMemsetD2D32Async",
+    "cuStreamGetPriority",
+    "cuStreamGetFlags",
+    "cuStreamGetCtx",
+    "cuStreamWaitEvent",
+    "cuStreamAddCallback",
+    "cuStreamAttachMemAsync",
+    "cuStreamQuery",
+    "cuStreamSynchronize",
+    "cuEventRecord",
+    "cuEventRecordWithFlags",
+    "cuLaunchKernel",
+    "cuLaunchHostFunc",
+    "cuGraphicsMapResources",
+    "cuGraphicsUnmapResources",
+    "cuStreamWriteValue32",
+    "cuStreamWaitValue32",
+    "cuStreamWriteValue64",
+    "cuStreamWaitValue64",
+    "cuStreamBatchMemOp",
+    "cuMemPrefetchAsync",
+    "cuLaunchCooperativeKernel",
+    "cuSignalExternalSemaphoresAsync",
+    "cuWaitExternalSemaphoresAsync",
+    "cuStreamBeginCapture",
+    "cuStreamBeginCapture_ptsz",
+    "cuStreamBeginCapture_v2",
+    "cuStreamEndCapture",
+    "cuStreamIsCapturing",
+    "cuStreamGetCaptureInfo",
+    "cuGraphUpload",
+    "cuGraphLaunch",
+    "cuStreamCopyAttributes",
+    "cuStreamGetAttribute",
+    "cuStreamSetAttribute",
+    "cuIpcOpenMemHandle",
+    "cuGraphInstantiate",
+    "cuMemMapArrayAsync",
+    "cuProfilerInitialize",
+    "cuProfilerStart",
+    "cuProfilerStop"};
+
+static void load_library() {
+    static bool done = false;
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lg{mtx};
+
+    if (done)
+        return;
+
+    void* handle = get_library_handle();
+    for (size_t i = 0; i < NR_FUNC; ++i) {
+        void* func;
+        if (!handle) {
+            func = nullptr;
+        } else {
+            func = resolve_library_func(handle, g_func_name[i]);
+        }
+        if (!func) {
+            func = g_func_table_error[i];
+        }
+        __atomic_store_n(g_func_table + i, func, __ATOMIC_RELAXED);
+    }
+    done = true;
+}
+
+CUresult _WRAPLIB_API_CALL cuGetErrorString(CUresult arg0, const char **arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUresult, const char **);
+    ON_ENTRY(cuGetErrorString);
+    f_ptr_t f = (f_ptr_t)(g_func_table[0]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGetErrorName(CUresult arg0, const char **arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUresult, const char **);
+    ON_ENTRY(cuGetErrorName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[1]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuInit(unsigned int arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int);
+    ON_ENTRY(cuInit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[2]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDriverGetVersion(int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *);
+    ON_ENTRY(cuDriverGetVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[3]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGet(CUdevice *arg0, int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, int);
+    ON_ENTRY(cuDeviceGet);
+    f_ptr_t f = (f_ptr_t)(g_func_table[4]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetCount(int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *);
+    ON_ENTRY(cuDeviceGetCount);
+    f_ptr_t f = (f_ptr_t)(g_func_table[5]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetName(char *arg0, int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
+    ON_ENTRY(cuDeviceGetName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[6]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetUuid(CUuuid *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUuuid *, CUdevice);
+    ON_ENTRY(cuDeviceGetUuid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetLuid(char *arg0, unsigned int *arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, unsigned int *, CUdevice);
+    ON_ENTRY(cuDeviceGetLuid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2(size_t *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUdevice);
+    ON_ENTRY(cuDeviceTotalMem_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetTexture1DLinearMaxWidth(size_t *arg0, CUarray_format arg1, unsigned arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUarray_format, unsigned, CUdevice);
+    ON_ENTRY(cuDeviceGetTexture1DLinearMaxWidth);
+    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_attribute, CUdevice);
+    ON_ENTRY(cuDeviceGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes(void *arg0, CUdevice arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdevice, int);
+    ON_ENTRY(cuDeviceGetNvSciSyncAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetProperties(CUdevprop *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevprop *, CUdevice);
+    ON_ENTRY(cuDeviceGetProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability(int *arg0, int *arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUdevice);
+    ON_ENTRY(cuDeviceComputeCapability);
+    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain(CUcontext *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRetain);
+    f_ptr_t f = (f_ptr_t)(g_func_table[15]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_v2(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRelease_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[16]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_v2(CUdevice arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int);
+    ON_ENTRY(cuDevicePrimaryCtxSetFlags_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[17]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState(CUdevice arg0, unsigned int *arg1, int *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int *, int *);
+    ON_ENTRY(cuDevicePrimaryCtxGetState);
+    f_ptr_t f = (f_ptr_t)(g_func_table[18]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_v2(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxReset_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[19]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxCreate_v2(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
+    ON_ENTRY(cuCtxCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[21]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxPushCurrent_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[22]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxPopCurrent_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[23]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetCurrent(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxSetCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[24]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetCurrent(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxGetCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[25]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetDevice(CUdevice *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *);
+    ON_ENTRY(cuCtxGetDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[26]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetFlags(unsigned int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *);
+    ON_ENTRY(cuCtxGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[27]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSynchronize() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuCtxSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[28]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetLimit(CUlimit arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlimit, size_t);
+    ON_ENTRY(cuCtxSetLimit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[29]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetLimit(size_t *arg0, CUlimit arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUlimit);
+    ON_ENTRY(cuCtxGetLimit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[30]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig(CUfunc_cache *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache *);
+    ON_ENTRY(cuCtxGetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[31]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig(CUfunc_cache arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache);
+    ON_ENTRY(cuCtxSetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[32]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig(CUsharedconfig *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig *);
+    ON_ENTRY(cuCtxGetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[33]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig(CUsharedconfig arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig);
+    ON_ENTRY(cuCtxSetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[34]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion(CUcontext arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int *);
+    ON_ENTRY(cuCtxGetApiVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[35]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange(int *arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *);
+    ON_ENTRY(cuCtxGetStreamPriorityRange);
+    f_ptr_t f = (f_ptr_t)(g_func_table[36]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxResetPersistingL2Cache() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuCtxResetPersistingL2Cache);
+    f_ptr_t f = (f_ptr_t)(g_func_table[37]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuCtxAttach(CUcontext *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int);
+    ON_ENTRY(cuCtxAttach);
+    f_ptr_t f = (f_ptr_t)(g_func_table[38]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDetach(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDetach);
+    f_ptr_t f = (f_ptr_t)(g_func_table[39]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoad(CUmodule *arg0, const char *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const char *);
+    ON_ENTRY(cuModuleLoad);
+    f_ptr_t f = (f_ptr_t)(g_func_table[40]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadData(CUmodule *arg0, const void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
+    ON_ENTRY(cuModuleLoadData);
+    f_ptr_t f = (f_ptr_t)(g_func_table[41]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuModuleLoadDataEx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[42]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary(CUmodule *arg0, const void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
+    ON_ENTRY(cuModuleLoadFatBinary);
+    f_ptr_t f = (f_ptr_t)(g_func_table[43]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleUnload(CUmodule arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule);
+    ON_ENTRY(cuModuleUnload);
+    f_ptr_t f = (f_ptr_t)(g_func_table[44]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetFunction(CUfunction *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetFunction);
+    f_ptr_t f = (f_ptr_t)(g_func_table[45]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetGlobal_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[46]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetTexRef(CUtexref *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetTexRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[47]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetSurfRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[48]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLinkCreate_v2(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
+    ON_ENTRY(cuLinkCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[49]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddData_v2(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddData_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[50]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddFile_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[51]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuLinkComplete(CUlinkState arg0, void **arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, void **, size_t *);
+    ON_ENTRY(cuLinkComplete);
+    f_ptr_t f = (f_ptr_t)(g_func_table[52]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLinkDestroy(CUlinkState arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState);
+    ON_ENTRY(cuLinkDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[53]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2(size_t *arg0, size_t *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, size_t *);
+    ON_ENTRY(cuMemGetInfo_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[54]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAlloc_v2(CUdeviceptr *arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t);
+    ON_ENTRY(cuMemAlloc_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[55]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, size_t, size_t, unsigned int);
+    ON_ENTRY(cuMemAllocPitch_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[56]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemFree_v2(CUdeviceptr arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
+    ON_ENTRY(cuMemFree_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[57]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUdeviceptr);
+    ON_ENTRY(cuMemGetAddressRange_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[58]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2(void **arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t);
+    ON_ENTRY(cuMemAllocHost_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[59]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemFreeHost(void *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
+    ON_ENTRY(cuMemFreeHost);
+    f_ptr_t f = (f_ptr_t)(g_func_table[60]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostAlloc(void **arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t, unsigned int);
+    ON_ENTRY(cuMemHostAlloc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[61]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, void *, unsigned int);
+    ON_ENTRY(cuMemHostGetDevicePointer_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[62]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetFlags(unsigned int *arg0, void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, void *);
+    ON_ENTRY(cuMemHostGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[63]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocManaged(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, unsigned int);
+    ON_ENTRY(cuMemAllocManaged);
+    f_ptr_t f = (f_ptr_t)(g_func_table[64]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId(CUdevice *arg0, const char *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, const char *);
+    ON_ENTRY(cuDeviceGetByPCIBusId);
+    f_ptr_t f = (f_ptr_t)(g_func_table[65]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId(char *arg0, int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
+    ON_ENTRY(cuDeviceGetPCIBusId);
+    f_ptr_t f = (f_ptr_t)(g_func_table[66]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle(CUipcEventHandle *arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcEventHandle *, CUevent);
+    ON_ENTRY(cuIpcGetEventHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[67]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle(CUevent *arg0, CUipcEventHandle arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, CUipcEventHandle);
+    ON_ENTRY(cuIpcOpenEventHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[68]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle(CUipcMemHandle *arg0, CUdeviceptr arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcMemHandle *, CUdeviceptr);
+    ON_ENTRY(cuIpcGetMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[69]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_v2(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUipcMemHandle, unsigned int);
+    ON_ENTRY(cuIpcOpenMemHandle_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[70]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle(CUdeviceptr arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
+    ON_ENTRY(cuIpcCloseMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[71]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2(void *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
+    ON_ENTRY(cuMemHostRegister_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[72]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostUnregister(void *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
+    ON_ENTRY(cuMemHostUnregister);
+    f_ptr_t f = (f_ptr_t)(g_func_table[73]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpy_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[74]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
+    ON_ENTRY(cuMemcpyPeer_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[75]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[76]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoH_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[77]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[78]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[79]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[80]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[81]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoH_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[82]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[83]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2D_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[84]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2DUnaligned_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[85]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds(const CUDA_MEMCPY3D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuMemcpy3D_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[86]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds(const CUDA_MEMCPY3D_PEER *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
+    ON_ENTRY(cuMemcpy3DPeer_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[87]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[88]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
+    ON_ENTRY(cuMemcpyPeerAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[89]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[90]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[91]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[92]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[93]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[94]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[95]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[96]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
+    ON_ENTRY(cuMemcpy3DPeerAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[97]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
+    ON_ENTRY(cuMemsetD8_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[98]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
+    ON_ENTRY(cuMemsetD16_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[99]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
+    ON_ENTRY(cuMemsetD32_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[100]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D8_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[101]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D16_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[102]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D32_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[103]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
+    ON_ENTRY(cuMemsetD8Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[104]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
+    ON_ENTRY(cuMemsetD16Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[105]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
+    ON_ENTRY(cuMemsetD32Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[106]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D8Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[107]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D16Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[108]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D32Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[109]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuArrayCreate_v2(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR *);
+    ON_ENTRY(cuArrayCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[110]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR *, CUarray);
+    ON_ENTRY(cuArrayGetDescriptor_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[111]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_SPARSE_PROPERTIES *, CUarray);
+    ON_ENTRY(cuArrayGetSparseProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[112]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUmipmappedArray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_SPARSE_PROPERTIES *, CUmipmappedArray);
+    ON_ENTRY(cuMipmappedArrayGetSparseProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[113]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayDestroy(CUarray arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray);
+    ON_ENTRY(cuArrayDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[114]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *);
+    ON_ENTRY(cuArray3DCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[115]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR *, CUarray);
+    ON_ENTRY(cuArray3DGetDescriptor_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[116]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int);
+    ON_ENTRY(cuMipmappedArrayCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[117]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUmipmappedArray, unsigned int);
+    ON_ENTRY(cuMipmappedArrayGetLevel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[118]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy(CUmipmappedArray arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray);
+    ON_ENTRY(cuMipmappedArrayDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[119]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemAddressReserve(CUdeviceptr *arg0, size_t arg1, size_t arg2, CUdeviceptr arg3, unsigned long long arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, size_t, CUdeviceptr, unsigned long long);
+    ON_ENTRY(cuMemAddressReserve);
+    f_ptr_t f = (f_ptr_t)(g_func_table[120]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemAddressFree(CUdeviceptr arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t);
+    ON_ENTRY(cuMemAddressFree);
+    f_ptr_t f = (f_ptr_t)(g_func_table[121]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemCreate(CUmemGenericAllocationHandle *arg0, size_t arg1, const CUmemAllocationProp *arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, size_t, const CUmemAllocationProp *, unsigned long long);
+    ON_ENTRY(cuMemCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[122]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemRelease(CUmemGenericAllocationHandle arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle);
+    ON_ENTRY(cuMemRelease);
+    f_ptr_t f = (f_ptr_t)(g_func_table[123]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemMap(CUdeviceptr arg0, size_t arg1, size_t arg2, CUmemGenericAllocationHandle arg3, unsigned long long arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long);
+    ON_ENTRY(cuMemMap);
+    f_ptr_t f = (f_ptr_t)(g_func_table[124]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_ptsz(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarrayMapInfo *, unsigned int, CUstream);
+    ON_ENTRY(cuMemMapArrayAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[125]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemUnmap(CUdeviceptr arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t);
+    ON_ENTRY(cuMemUnmap);
+    f_ptr_t f = (f_ptr_t)(g_func_table[126]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemSetAccess(CUdeviceptr arg0, size_t arg1, const CUmemAccessDesc *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, const CUmemAccessDesc *, size_t);
+    ON_ENTRY(cuMemSetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[127]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAccess(unsigned long long *arg0, const CUmemLocation *arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned long long *, const CUmemLocation *, CUdeviceptr);
+    ON_ENTRY(cuMemGetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[128]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle(void *arg0, CUmemGenericAllocationHandle arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long);
+    ON_ENTRY(cuMemExportToShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[129]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle(CUmemGenericAllocationHandle *arg0, void *arg1, CUmemAllocationHandleType arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, void *, CUmemAllocationHandleType);
+    ON_ENTRY(cuMemImportFromShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[130]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity(size_t *arg0, const CUmemAllocationProp *arg1, CUmemAllocationGranularity_flags arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, const CUmemAllocationProp *, CUmemAllocationGranularity_flags);
+    ON_ENTRY(cuMemGetAllocationGranularity);
+    f_ptr_t f = (f_ptr_t)(g_func_table[131]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp *arg0, CUmemGenericAllocationHandle arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemAllocationProp *, CUmemGenericAllocationHandle);
+    ON_ENTRY(cuMemGetAllocationPropertiesFromHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[132]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemRetainAllocationHandle(CUmemGenericAllocationHandle *arg0, void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, void *);
+    ON_ENTRY(cuMemRetainAllocationHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[133]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuPointerGetAttribute(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUpointer_attribute, CUdeviceptr);
+    ON_ENTRY(cuPointerGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[134]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[135]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemAdvise(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUmem_advise, CUdevice);
+    ON_ENTRY(cuMemAdvise);
+    f_ptr_t f = (f_ptr_t)(g_func_table[136]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemRangeGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[137]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemRangeGetAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[138]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuPointerSetAttribute(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void *, CUpointer_attribute, CUdeviceptr);
+    ON_ENTRY(cuPointerSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[139]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuPointerGetAttributes(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUpointer_attribute *, void **, CUdeviceptr);
+    ON_ENTRY(cuPointerGetAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[140]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCreate(CUstream *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int);
+    ON_ENTRY(cuStreamCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[141]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority(CUstream *arg0, unsigned int arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int, int);
+    ON_ENTRY(cuStreamCreateWithPriority);
+    f_ptr_t f = (f_ptr_t)(g_func_table[142]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz(CUstream arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
+    ON_ENTRY(cuStreamGetPriority_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[143]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz(CUstream arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
+    ON_ENTRY(cuStreamGetFlags_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[144]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[145]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
+    ON_ENTRY(cuStreamWaitEvent_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[146]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
+    ON_ENTRY(cuStreamAddCallback_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[147]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[148]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstreamCaptureMode *);
+    ON_ENTRY(cuThreadExchangeStreamCaptureMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[149]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[150]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[151]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[152]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
+    ON_ENTRY(cuStreamAttachMemAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[153]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamQuery_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[154]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamSynchronize_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[155]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[156]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_ptsz(CUstream arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstream);
+    ON_ENTRY(cuStreamCopyAttributes_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[157]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_ptsz(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, CUstreamAttrValue *);
+    ON_ENTRY(cuStreamGetAttribute_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[158]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_ptsz(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, const CUstreamAttrValue *);
+    ON_ENTRY(cuStreamSetAttribute_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[159]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuEventCreate(CUevent *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, unsigned int);
+    ON_ENTRY(cuEventCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[160]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz(CUevent arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
+    ON_ENTRY(cuEventRecord_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[161]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_ptsz(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream, unsigned int);
+    ON_ENTRY(cuEventRecordWithFlags_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[162]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuEventQuery(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventQuery);
+    f_ptr_t f = (f_ptr_t)(g_func_table[163]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventSynchronize(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[164]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventDestroy_v2(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[165]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventElapsedTime(float *arg0, CUevent arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUevent, CUevent);
+    ON_ENTRY(cuEventElapsedTime);
+    f_ptr_t f = (f_ptr_t)(g_func_table[166]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalMemory(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[167]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedBuffer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[168]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[169]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory(CUexternalMemory arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory);
+    ON_ENTRY(cuDestroyExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[170]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[171]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[172]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[173]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore(CUexternalSemaphore arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore);
+    ON_ENTRY(cuDestroyExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[174]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue32_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[175]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[176]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue32_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[177]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[178]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
+    ON_ENTRY(cuStreamBatchMemOp_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[179]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuFuncGetAttribute(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction_attribute, CUfunction);
+    ON_ENTRY(cuFuncGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[180]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetAttribute(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunction_attribute, int);
+    ON_ENTRY(cuFuncSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[181]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig(CUfunction arg0, CUfunc_cache arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunc_cache);
+    ON_ENTRY(cuFuncSetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[182]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig(CUfunction arg0, CUsharedconfig arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUsharedconfig);
+    ON_ENTRY(cuFuncSetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[183]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
+    ON_ENTRY(cuLaunchKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[184]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[185]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int);
+    ON_ENTRY(cuLaunchCooperativeKernelMultiDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[186]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[187]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape(CUfunction arg0, int arg1, int arg2, int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, int);
+    ON_ENTRY(cuFuncSetBlockShape);
+    f_ptr_t f = (f_ptr_t)(g_func_table[188]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize(CUfunction arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
+    ON_ENTRY(cuFuncSetSharedSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[189]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetSize(CUfunction arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
+    ON_ENTRY(cuParamSetSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[190]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuParamSeti(CUfunction arg0, int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, unsigned int);
+    ON_ENTRY(cuParamSeti);
+    f_ptr_t f = (f_ptr_t)(g_func_table[191]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetf(CUfunction arg0, int arg1, float arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, float);
+    ON_ENTRY(cuParamSetf);
+    f_ptr_t f = (f_ptr_t)(g_func_table[192]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetv(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, void *, unsigned int);
+    ON_ENTRY(cuParamSetv);
+    f_ptr_t f = (f_ptr_t)(g_func_table[193]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLaunch(CUfunction arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction);
+    ON_ENTRY(cuLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[194]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchGrid(CUfunction arg0, int arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int);
+    ON_ENTRY(cuLaunchGrid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[195]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchGridAsync(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, CUstream);
+    ON_ENTRY(cuLaunchGridAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[196]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetTexRef(CUfunction arg0, int arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, CUtexref);
+    ON_ENTRY(cuParamSetTexRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[197]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphCreate(CUgraph *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, unsigned int);
+    ON_ENTRY(cuGraphCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[198]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddKernelNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[199]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[200]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[201]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphAddMemcpyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[202]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[203]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[204]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphAddMemsetNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[205]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[206]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[207]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddHostNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddHostNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[208]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[209]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[210]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph);
+    ON_ENTRY(cuGraphAddChildGraphNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[211]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph(CUgraphNode arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraph *);
+    ON_ENTRY(cuGraphChildGraphNodeGetGraph);
+    f_ptr_t f = (f_ptr_t)(g_func_table[212]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddEmptyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[213]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEventRecordNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent);
+    ON_ENTRY(cuGraphAddEventRecordNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[214]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeGetEvent(CUgraphNode arg0, CUevent *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent *);
+    ON_ENTRY(cuGraphEventRecordNodeGetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[215]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeSetEvent(CUgraphNode arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphEventRecordNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[216]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEventWaitNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent);
+    ON_ENTRY(cuGraphAddEventWaitNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[217]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeGetEvent(CUgraphNode arg0, CUevent *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent *);
+    ON_ENTRY(cuGraphEventWaitNodeGetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[218]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeSetEvent(CUgraphNode arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphEventWaitNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[219]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphClone(CUgraph *arg0, CUgraph arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, CUgraph);
+    ON_ENTRY(cuGraphClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[220]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraphNode, CUgraph);
+    ON_ENTRY(cuGraphNodeFindInClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[221]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetType(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNodeType *);
+    ON_ENTRY(cuGraphNodeGetType);
+    f_ptr_t f = (f_ptr_t)(g_func_table[222]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[223]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetRootNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[224]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetEdges(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetEdges);
+    f_ptr_t f = (f_ptr_t)(g_func_table[225]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[226]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependentNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[227]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[228]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphRemoveDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[229]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroyNode(CUgraphNode arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode);
+    ON_ENTRY(cuGraphDestroyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[230]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphInstantiate_v2(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t);
+    ON_ENTRY(cuGraphInstantiate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[231]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[232]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMCPY3D *arg2, CUcontext arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphExecMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[233]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMSET_NODE_PARAMS *arg2, CUcontext arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphExecMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[234]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_HOST_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[235]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecChildGraphNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, CUgraph arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, CUgraph);
+    ON_ENTRY(cuGraphExecChildGraphNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[236]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecEventRecordNodeSetEvent(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphExecEventRecordNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[237]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecEventWaitNodeSetEvent(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphExecEventWaitNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[238]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphUpload_ptsz(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphUpload_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[239]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[240]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecDestroy(CUgraphExec arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec);
+    ON_ENTRY(cuGraphExecDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[241]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroy(CUgraph arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph);
+    ON_ENTRY(cuGraphDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[242]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecUpdate(CUgraphExec arg0, CUgraph arg1, CUgraphNode *arg2, CUgraphExecUpdateResult *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraph, CUgraphNode *, CUgraphExecUpdateResult *);
+    ON_ENTRY(cuGraphExecUpdate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[243]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeCopyAttributes(CUgraphNode arg0, CUgraphNode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode);
+    ON_ENTRY(cuGraphKernelNodeCopyAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[244]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetAttribute(CUgraphNode arg0, CUkernelNodeAttrID arg1, CUkernelNodeAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUkernelNodeAttrID, CUkernelNodeAttrValue *);
+    ON_ENTRY(cuGraphKernelNodeGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[245]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetAttribute(CUgraphNode arg0, CUkernelNodeAttrID arg1, const CUkernelNodeAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUkernelNodeAttrID, const CUkernelNodeAttrValue *);
+    ON_ENTRY(cuGraphKernelNodeSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[246]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t);
+    ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[247]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t, unsigned int);
+    ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[248]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int);
+    ON_ENTRY(cuOccupancyMaxPotentialBlockSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[249]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int);
+    ON_ENTRY(cuOccupancyMaxPotentialBlockSizeWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[250]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyAvailableDynamicSMemPerBlock(size_t *arg0, CUfunction arg1, int arg2, int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUfunction, int, int);
+    ON_ENTRY(cuOccupancyAvailableDynamicSMemPerBlock);
+    f_ptr_t f = (f_ptr_t)(g_func_table[251]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetArray(CUtexref arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray, unsigned int);
+    ON_ENTRY(cuTexRefSetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[252]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUmipmappedArray, unsigned int);
+    ON_ENTRY(cuTexRefSetMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[253]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUtexref, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[254]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress2D_v3);
+    f_ptr_t f = (f_ptr_t)(g_func_table[255]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFormat(CUtexref arg0, CUarray_format arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray_format, int);
+    ON_ENTRY(cuTexRefSetFormat);
+    f_ptr_t f = (f_ptr_t)(g_func_table[256]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode(CUtexref arg0, int arg1, CUaddress_mode arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, int, CUaddress_mode);
+    ON_ENTRY(cuTexRefSetAddressMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[257]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode(CUtexref arg0, CUfilter_mode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
+    ON_ENTRY(cuTexRefSetFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[258]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode(CUtexref arg0, CUfilter_mode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
+    ON_ENTRY(cuTexRefSetMipmapFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[259]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias(CUtexref arg0, float arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float);
+    ON_ENTRY(cuTexRefSetMipmapLevelBias);
+    f_ptr_t f = (f_ptr_t)(g_func_table[260]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp(CUtexref arg0, float arg1, float arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float, float);
+    ON_ENTRY(cuTexRefSetMipmapLevelClamp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[261]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy(CUtexref arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
+    ON_ENTRY(cuTexRefSetMaxAnisotropy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[262]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor(CUtexref arg0, float *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float *);
+    ON_ENTRY(cuTexRefSetBorderColor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[263]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFlags(CUtexref arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
+    ON_ENTRY(cuTexRefSetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[264]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2(CUdeviceptr *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUtexref);
+    ON_ENTRY(cuTexRefGetAddress_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[265]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetArray(CUarray *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUtexref);
+    ON_ENTRY(cuTexRefGetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[266]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray(CUmipmappedArray *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[267]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUaddress_mode *, CUtexref, int);
+    ON_ENTRY(cuTexRefGetAddressMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[268]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
+    ON_ENTRY(cuTexRefGetFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[269]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFormat(CUarray_format *arg0, int *arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray_format *, int *, CUtexref);
+    ON_ENTRY(cuTexRefGetFormat);
+    f_ptr_t f = (f_ptr_t)(g_func_table[270]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[271]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias(float *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapLevelBias);
+    f_ptr_t f = (f_ptr_t)(g_func_table[272]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp(float *arg0, float *arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, float *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapLevelClamp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[273]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy(int *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUtexref);
+    ON_ENTRY(cuTexRefGetMaxAnisotropy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[274]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor(float *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
+    ON_ENTRY(cuTexRefGetBorderColor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[275]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFlags(unsigned int *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref);
+    ON_ENTRY(cuTexRefGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[276]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefCreate(CUtexref *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *);
+    ON_ENTRY(cuTexRefCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[277]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefDestroy(CUtexref arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref);
+    ON_ENTRY(cuTexRefDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[278]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuSurfRefSetArray(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref, CUarray, unsigned int);
+    ON_ENTRY(cuSurfRefSetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[279]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuSurfRefGetArray(CUarray *arg0, CUsurfref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUsurfref);
+    ON_ENTRY(cuSurfRefGetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[280]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectCreate(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *);
+    ON_ENTRY(cuTexObjectCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[281]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectDestroy(CUtexObject arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject);
+    ON_ENTRY(cuTexObjectDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[282]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetResourceDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[283]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_TEXTURE_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetTextureDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[284]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_VIEW_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetResourceViewDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[285]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectCreate(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject *, const CUDA_RESOURCE_DESC *);
+    ON_ENTRY(cuSurfObjectCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[286]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy(CUsurfObject arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject);
+    ON_ENTRY(cuSurfObjectDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[287]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUsurfObject);
+    ON_ENTRY(cuSurfObjectGetResourceDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[288]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer(int *arg0, CUdevice arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceCanAccessPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[289]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess(CUcontext arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int);
+    ON_ENTRY(cuCtxEnablePeerAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[290]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDisablePeerAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[291]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_P2PAttribute, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceGetP2PAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[292]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource(CUgraphicsResource arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource);
+    ON_ENTRY(cuGraphicsUnregisterResource);
+    f_ptr_t f = (f_ptr_t)(g_func_table[293]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUgraphicsResource, unsigned int, unsigned int);
+    ON_ENTRY(cuGraphicsSubResourceGetMappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[294]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[295]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedPointer_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[296]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2(CUgraphicsResource arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
+    ON_ENTRY(cuGraphicsResourceSetMapFlags_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[297]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsMapResources_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[298]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsUnmapResources_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[299]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGetExportTable(const void **arg0, const CUuuid *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void **, const CUuuid *);
+    ON_ENTRY(cuGetExportTable);
+    f_ptr_t f = (f_ptr_t)(g_func_table[300]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuFuncGetModule(CUmodule *arg0, CUfunction arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, CUfunction);
+    ON_ENTRY(cuFuncGetModule);
+    f_ptr_t f = (f_ptr_t)(g_func_table[301]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostRegister(void *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
+    ON_ENTRY(cuMemHostRegister);
+    f_ptr_t f = (f_ptr_t)(g_func_table[302]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags(CUgraphicsResource arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
+    ON_ENTRY(cuGraphicsResourceSetMapFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[303]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLinkCreate(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
+    ON_ENTRY(cuLinkCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[304]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddData(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddData);
+    f_ptr_t f = (f_ptr_t)(g_func_table[305]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddFile(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddFile);
+    f_ptr_t f = (f_ptr_t)(g_func_table[306]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress2D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[307]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceTotalMem(unsigned int *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUdevice);
+    ON_ENTRY(cuDeviceTotalMem);
+    f_ptr_t f = (f_ptr_t)(g_func_table[308]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxCreate(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
+    ON_ENTRY(cuCtxCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[309]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetGlobal(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetGlobal);
+    f_ptr_t f = (f_ptr_t)(g_func_table[310]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetInfo(unsigned int *arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, unsigned int *);
+    ON_ENTRY(cuMemGetInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[311]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAlloc(CUdeviceptr_v1 *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int);
+    ON_ENTRY(cuMemAlloc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[312]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocPitch(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int);
+    ON_ENTRY(cuMemAllocPitch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[313]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemFree(CUdeviceptr_v1 arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1);
+    ON_ENTRY(cuMemFree);
+    f_ptr_t f = (f_ptr_t)(g_func_table[314]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAddressRange(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1);
+    ON_ENTRY(cuMemGetAddressRange);
+    f_ptr_t f = (f_ptr_t)(g_func_table[315]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocHost(void **arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, unsigned int);
+    ON_ENTRY(cuMemAllocHost);
+    f_ptr_t f = (f_ptr_t)(g_func_table[316]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, void *, unsigned int);
+    ON_ENTRY(cuMemHostGetDevicePointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[317]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int);
+    ON_ENTRY(cuMemcpyHtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[318]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoH);
+    f_ptr_t f = (f_ptr_t)(g_func_table[319]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[320]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[321]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[322]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int);
+    ON_ENTRY(cuMemcpyHtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[323]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoH);
+    f_ptr_t f = (f_ptr_t)(g_func_table[324]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[325]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[326]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[327]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D(const CUDA_MEMCPY2D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
+    ON_ENTRY(cuMemcpy2D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[328]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned(const CUDA_MEMCPY2D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
+    ON_ENTRY(cuMemcpy2DUnaligned);
+    f_ptr_t f = (f_ptr_t)(g_func_table[329]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D(const CUDA_MEMCPY3D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *);
+    ON_ENTRY(cuMemcpy3D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[330]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[331]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[332]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[333]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[334]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[335]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned char, unsigned int);
+    ON_ENTRY(cuMemsetD8);
+    f_ptr_t f = (f_ptr_t)(g_func_table[336]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned short, unsigned int);
+    ON_ENTRY(cuMemsetD16);
+    f_ptr_t f = (f_ptr_t)(g_func_table[337]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[338]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D8);
+    f_ptr_t f = (f_ptr_t)(g_func_table[339]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D16);
+    f_ptr_t f = (f_ptr_t)(g_func_table[340]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[341]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuArrayCreate(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *);
+    ON_ENTRY(cuArrayCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[342]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray);
+    ON_ENTRY(cuArrayGetDescriptor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[343]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DCreate(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *);
+    ON_ENTRY(cuArray3DCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[344]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray);
+    ON_ENTRY(cuArray3DGetDescriptor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[345]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuTexRefSetAddress);
+    f_ptr_t f = (f_ptr_t)(g_func_table[346]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuTexRefSetAddress2D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[347]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddress(CUdeviceptr_v1 *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, CUtexref);
+    ON_ENTRY(cuTexRefGetAddress);
+    f_ptr_t f = (f_ptr_t)(g_func_table[348]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedPointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[349]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDestroy(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[350]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPopCurrent(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxPopCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[351]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPushCurrent(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxPushCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[352]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamDestroy(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[353]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventDestroy(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[354]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRelease);
+    f_ptr_t f = (f_ptr_t)(g_func_table[355]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxReset);
+    f_ptr_t f = (f_ptr_t)(g_func_table[356]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags(CUdevice arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int);
+    ON_ENTRY(cuDevicePrimaryCtxSetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[357]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[358]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoH_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[359]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[360]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[361]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[362]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[363]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoH_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[364]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[365]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[366]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[367]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[368]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2DUnaligned_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[369]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2(const CUDA_MEMCPY3D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuMemcpy3D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[370]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[371]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[372]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[373]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[374]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[375]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8_v2(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
+    ON_ENTRY(cuMemsetD8_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[376]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16_v2(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
+    ON_ENTRY(cuMemsetD16_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[377]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32_v2(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
+    ON_ENTRY(cuMemsetD32_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[378]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D8_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[379]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D16_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[380]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D32_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[381]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[382]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAsync(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[383]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeer(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
+    ON_ENTRY(cuMemcpyPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[384]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
+    ON_ENTRY(cuMemcpyPeerAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[385]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
+    ON_ENTRY(cuMemcpy3DPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[386]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
+    ON_ENTRY(cuMemcpy3DPeerAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[387]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8Async(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
+    ON_ENTRY(cuMemsetD8Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[388]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16Async(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
+    ON_ENTRY(cuMemsetD16Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[389]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32Async(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
+    ON_ENTRY(cuMemsetD32Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[390]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D8Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[391]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D16Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[392]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D32Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[393]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetPriority(CUstream arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
+    ON_ENTRY(cuStreamGetPriority);
+    f_ptr_t f = (f_ptr_t)(g_func_table[394]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetFlags(CUstream arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
+    ON_ENTRY(cuStreamGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[395]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[396]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitEvent(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
+    ON_ENTRY(cuStreamWaitEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[397]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAddCallback(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
+    ON_ENTRY(cuStreamAddCallback);
+    f_ptr_t f = (f_ptr_t)(g_func_table[398]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
+    ON_ENTRY(cuStreamAttachMemAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[399]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamQuery(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamQuery);
+    f_ptr_t f = (f_ptr_t)(g_func_table[400]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSynchronize(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[401]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecord(CUevent arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
+    ON_ENTRY(cuEventRecord);
+    f_ptr_t f = (f_ptr_t)(g_func_table[402]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream, unsigned int);
+    ON_ENTRY(cuEventRecordWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[403]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
+    ON_ENTRY(cuLaunchKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[404]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[405]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsMapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsMapResources);
+    f_ptr_t f = (f_ptr_t)(g_func_table[406]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsUnmapResources);
+    f_ptr_t f = (f_ptr_t)(g_func_table[407]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[408]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[409]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[410]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[411]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
+    ON_ENTRY(cuStreamBatchMemOp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[412]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[413]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[414]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[415]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[416]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[417]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[418]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[419]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[420]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing);
+    f_ptr_t f = (f_ptr_t)(g_func_table[421]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[422]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphUpload(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphUpload);
+    f_ptr_t f = (f_ptr_t)(g_func_table[423]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[424]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes(CUstream arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstream);
+    ON_ENTRY(cuStreamCopyAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[425]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetAttribute(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, CUstreamAttrValue *);
+    ON_ENTRY(cuStreamGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[426]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSetAttribute(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, const CUstreamAttrValue *);
+    ON_ENTRY(cuStreamSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[427]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUipcMemHandle, unsigned int);
+    ON_ENTRY(cuIpcOpenMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[428]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphInstantiate(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t);
+    ON_ENTRY(cuGraphInstantiate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[429]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarrayMapInfo *, unsigned int, CUstream);
+    ON_ENTRY(cuMemMapArrayAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[430]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuProfilerInitialize(const char *arg0, const char *arg1, CUoutput_mode arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const char *, const char *, CUoutput_mode);
+    ON_ENTRY(cuProfilerInitialize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[431]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuProfilerStart() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuProfilerStart);
+    f_ptr_t f = (f_ptr_t)(g_func_table[432]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuProfilerStop() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuProfilerStop);
+    f_ptr_t f = (f_ptr_t)(g_func_table[433]);
+    return f();
+}
diff --git a/dnn/cuda-stub/src/libcuda-wrap_11.2.h b/dnn/cuda-stub/src/libcuda-wrap_11.2.h
new file mode 100644
index 0000000000000000000000000000000000000000..738aef5a994d103a1af2a1cc00b1e0ebca97dd9b
--- /dev/null
+++ b/dnn/cuda-stub/src/libcuda-wrap_11.2.h
@@ -0,0 +1,7454 @@
+// generated by wraplib.py
+// --- begin functions to be implemented
+#ifndef _WRAPLIB_API_CALL
+#define _WRAPLIB_API_CALL
+#endif
+#ifndef _WRAPLIB_CALLBACK
+#define _WRAPLIB_CALLBACK
+#endif
+#ifndef ON_ENTRY
+#define ON_ENTRY(x)
+#endif
+static void* get_library_handle();
+static void* resolve_library_func(void* , const char*);
+namespace {
+template<typename T> T on_init_failed(int func_idx);
+}
+// --- end functions to be implemented
+#include <mutex>
+#include <cstddef>
+static void load_library();
+static CUresult _WRAPLIB_API_CALL cuGetErrorString_init(CUresult arg0, const char **arg1) {
+    load_library();
+    return cuGetErrorString(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorString_error(CUresult, const char **) {
+    return on_init_failed<CUresult >(0);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorName_init(CUresult arg0, const char **arg1) {
+    load_library();
+    return cuGetErrorName(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetErrorName_error(CUresult, const char **) {
+    return on_init_failed<CUresult >(1);
+}
+static CUresult _WRAPLIB_API_CALL cuInit_init(unsigned int arg0) {
+    load_library();
+    return cuInit(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuInit_error(unsigned int) {
+    return on_init_failed<CUresult >(2);
+}
+static CUresult _WRAPLIB_API_CALL cuDriverGetVersion_init(int *arg0) {
+    load_library();
+    return cuDriverGetVersion(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDriverGetVersion_error(int *) {
+    return on_init_failed<CUresult >(3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGet_init(CUdevice *arg0, int arg1) {
+    load_library();
+    return cuDeviceGet(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGet_error(CUdevice *, int) {
+    return on_init_failed<CUresult >(4);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetCount_init(int *arg0) {
+    load_library();
+    return cuDeviceGetCount(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetCount_error(int *) {
+    return on_init_failed<CUresult >(5);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetName_init(char *arg0, int arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetName(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetName_error(char *, int, CUdevice) {
+    return on_init_failed<CUresult >(6);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_init(CUuuid *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetUuid(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetUuid_error(CUuuid *, CUdevice) {
+    return on_init_failed<CUresult >(7);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetLuid_init(char *arg0, unsigned int *arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetLuid(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetLuid_error(char *, unsigned int *, CUdevice) {
+    return on_init_failed<CUresult >(8);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_init(size_t *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceTotalMem_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2_error(size_t *, CUdevice) {
+    return on_init_failed<CUresult >(9);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetTexture1DLinearMaxWidth_init(size_t *arg0, CUarray_format arg1, unsigned arg2, CUdevice arg3) {
+    load_library();
+    return cuDeviceGetTexture1DLinearMaxWidth(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetTexture1DLinearMaxWidth_error(size_t *, CUarray_format, unsigned, CUdevice) {
+    return on_init_failed<CUresult >(10);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_init(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute_error(int *, CUdevice_attribute, CUdevice) {
+    return on_init_failed<CUresult >(11);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes_init(void *arg0, CUdevice arg1, int arg2) {
+    load_library();
+    return cuDeviceGetNvSciSyncAttributes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes_error(void *, CUdevice, int) {
+    return on_init_failed<CUresult >(12);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceSetMemPool_init(CUdevice arg0, CUmemoryPool arg1) {
+    load_library();
+    return cuDeviceSetMemPool(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceSetMemPool_error(CUdevice, CUmemoryPool) {
+    return on_init_failed<CUresult >(13);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetMemPool_init(CUmemoryPool *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetMemPool(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetMemPool_error(CUmemoryPool *, CUdevice) {
+    return on_init_failed<CUresult >(14);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetDefaultMemPool_init(CUmemoryPool *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetDefaultMemPool(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetDefaultMemPool_error(CUmemoryPool *, CUdevice) {
+    return on_init_failed<CUresult >(15);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_init(CUdevprop *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceGetProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetProperties_error(CUdevprop *, CUdevice) {
+    return on_init_failed<CUresult >(16);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_init(int *arg0, int *arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceComputeCapability(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability_error(int *, int *, CUdevice) {
+    return on_init_failed<CUresult >(17);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_init(CUcontext *arg0, CUdevice arg1) {
+    load_library();
+    return cuDevicePrimaryCtxRetain(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain_error(CUcontext *, CUdevice) {
+    return on_init_failed<CUresult >(18);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_v2_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxRelease_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_v2_error(CUdevice) {
+    return on_init_failed<CUresult >(19);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_v2_init(CUdevice arg0, unsigned int arg1) {
+    load_library();
+    return cuDevicePrimaryCtxSetFlags_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_v2_error(CUdevice, unsigned int) {
+    return on_init_failed<CUresult >(20);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_init(CUdevice arg0, unsigned int *arg1, int *arg2) {
+    load_library();
+    return cuDevicePrimaryCtxGetState(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState_error(CUdevice, unsigned int *, int *) {
+    return on_init_failed<CUresult >(21);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_v2_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxReset_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_v2_error(CUdevice) {
+    return on_init_failed<CUresult >(22);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    load_library();
+    return cuCtxCreate_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_v2_error(CUcontext *, unsigned int, CUdevice) {
+    return on_init_failed<CUresult >(23);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2_error(CUcontext) {
+    return on_init_failed<CUresult >(24);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_init(CUcontext arg0) {
+    load_library();
+    return cuCtxPushCurrent_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2_error(CUcontext) {
+    return on_init_failed<CUresult >(25);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxPopCurrent_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2_error(CUcontext *) {
+    return on_init_failed<CUresult >(26);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_init(CUcontext arg0) {
+    load_library();
+    return cuCtxSetCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCurrent_error(CUcontext) {
+    return on_init_failed<CUresult >(27);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxGetCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCurrent_error(CUcontext *) {
+    return on_init_failed<CUresult >(28);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_init(CUdevice *arg0) {
+    load_library();
+    return cuCtxGetDevice(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetDevice_error(CUdevice *) {
+    return on_init_failed<CUresult >(29);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_init(unsigned int *arg0) {
+    load_library();
+    return cuCtxGetFlags(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetFlags_error(unsigned int *) {
+    return on_init_failed<CUresult >(30);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_init() {
+    load_library();
+    return cuCtxSynchronize();
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSynchronize_error() {
+    return on_init_failed<CUresult >(31);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_init(CUlimit arg0, size_t arg1) {
+    load_library();
+    return cuCtxSetLimit(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetLimit_error(CUlimit, size_t) {
+    return on_init_failed<CUresult >(32);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_init(size_t *arg0, CUlimit arg1) {
+    load_library();
+    return cuCtxGetLimit(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetLimit_error(size_t *, CUlimit) {
+    return on_init_failed<CUresult >(33);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_init(CUfunc_cache *arg0) {
+    load_library();
+    return cuCtxGetCacheConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig_error(CUfunc_cache *) {
+    return on_init_failed<CUresult >(34);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_init(CUfunc_cache arg0) {
+    load_library();
+    return cuCtxSetCacheConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig_error(CUfunc_cache) {
+    return on_init_failed<CUresult >(35);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_init(CUsharedconfig *arg0) {
+    load_library();
+    return cuCtxGetSharedMemConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig_error(CUsharedconfig *) {
+    return on_init_failed<CUresult >(36);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_init(CUsharedconfig arg0) {
+    load_library();
+    return cuCtxSetSharedMemConfig(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig_error(CUsharedconfig) {
+    return on_init_failed<CUresult >(37);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_init(CUcontext arg0, unsigned int *arg1) {
+    load_library();
+    return cuCtxGetApiVersion(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion_error(CUcontext, unsigned int *) {
+    return on_init_failed<CUresult >(38);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_init(int *arg0, int *arg1) {
+    load_library();
+    return cuCtxGetStreamPriorityRange(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange_error(int *, int *) {
+    return on_init_failed<CUresult >(39);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxResetPersistingL2Cache_init() {
+    load_library();
+    return cuCtxResetPersistingL2Cache();
+}
+static CUresult _WRAPLIB_API_CALL cuCtxResetPersistingL2Cache_error() {
+    return on_init_failed<CUresult >(40);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxAttach_init(CUcontext *arg0, unsigned int arg1) {
+    load_library();
+    return cuCtxAttach(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxAttach_error(CUcontext *, unsigned int) {
+    return on_init_failed<CUresult >(41);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDetach_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDetach(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDetach_error(CUcontext) {
+    return on_init_failed<CUresult >(42);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoad_init(CUmodule *arg0, const char *arg1) {
+    load_library();
+    return cuModuleLoad(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoad_error(CUmodule *, const char *) {
+    return on_init_failed<CUresult >(43);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadData_init(CUmodule *arg0, const void *arg1) {
+    load_library();
+    return cuModuleLoadData(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadData_error(CUmodule *, const void *) {
+    return on_init_failed<CUresult >(44);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_init(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
+    load_library();
+    return cuModuleLoadDataEx(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx_error(CUmodule *, const void *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(45);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_init(CUmodule *arg0, const void *arg1) {
+    load_library();
+    return cuModuleLoadFatBinary(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary_error(CUmodule *, const void *) {
+    return on_init_failed<CUresult >(46);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleUnload_init(CUmodule arg0) {
+    load_library();
+    return cuModuleUnload(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleUnload_error(CUmodule) {
+    return on_init_failed<CUresult >(47);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_init(CUfunction *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetFunction(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetFunction_error(CUfunction *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(48);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_init(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
+    load_library();
+    return cuModuleGetGlobal_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2_error(CUdeviceptr *, size_t *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(49);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_init(CUtexref *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetTexRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetTexRef_error(CUtexref *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(50);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_init(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
+    load_library();
+    return cuModuleGetSurfRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef_error(CUsurfref *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(51);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    load_library();
+    return cuLinkCreate_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_v2_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
+    return on_init_failed<CUresult >(52);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    load_library();
+    return cuLinkAddData_v2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_v2_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(53);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    load_library();
+    return cuLinkAddFile_v2(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(54);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkComplete_init(CUlinkState arg0, void **arg1, size_t *arg2) {
+    load_library();
+    return cuLinkComplete(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkComplete_error(CUlinkState, void **, size_t *) {
+    return on_init_failed<CUresult >(55);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkDestroy_init(CUlinkState arg0) {
+    load_library();
+    return cuLinkDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkDestroy_error(CUlinkState) {
+    return on_init_failed<CUresult >(56);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_init(size_t *arg0, size_t *arg1) {
+    load_library();
+    return cuMemGetInfo_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2_error(size_t *, size_t *) {
+    return on_init_failed<CUresult >(57);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_init(CUdeviceptr *arg0, size_t arg1) {
+    load_library();
+    return cuMemAlloc_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_v2_error(CUdeviceptr *, size_t) {
+    return on_init_failed<CUresult >(58);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_init(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
+    load_library();
+    return cuMemAllocPitch_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2_error(CUdeviceptr *, size_t *, size_t, size_t, unsigned int) {
+    return on_init_failed<CUresult >(59);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_v2_init(CUdeviceptr arg0) {
+    load_library();
+    return cuMemFree_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_v2_error(CUdeviceptr) {
+    return on_init_failed<CUresult >(60);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_init(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuMemGetAddressRange_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2_error(CUdeviceptr *, size_t *, CUdeviceptr) {
+    return on_init_failed<CUresult >(61);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_init(void **arg0, size_t arg1) {
+    load_library();
+    return cuMemAllocHost_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2_error(void **, size_t) {
+    return on_init_failed<CUresult >(62);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeHost_init(void *arg0) {
+    load_library();
+    return cuMemFreeHost(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeHost_error(void *) {
+    return on_init_failed<CUresult >(63);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_init(void **arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostAlloc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostAlloc_error(void **, size_t, unsigned int) {
+    return on_init_failed<CUresult >(64);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_init(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostGetDevicePointer_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2_error(CUdeviceptr *, void *, unsigned int) {
+    return on_init_failed<CUresult >(65);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_init(unsigned int *arg0, void *arg1) {
+    load_library();
+    return cuMemHostGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetFlags_error(unsigned int *, void *) {
+    return on_init_failed<CUresult >(66);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_init(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemAllocManaged(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocManaged_error(CUdeviceptr *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(67);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_init(CUdevice *arg0, const char *arg1) {
+    load_library();
+    return cuDeviceGetByPCIBusId(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId_error(CUdevice *, const char *) {
+    return on_init_failed<CUresult >(68);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_init(char *arg0, int arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceGetPCIBusId(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId_error(char *, int, CUdevice) {
+    return on_init_failed<CUresult >(69);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_init(CUipcEventHandle *arg0, CUevent arg1) {
+    load_library();
+    return cuIpcGetEventHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle_error(CUipcEventHandle *, CUevent) {
+    return on_init_failed<CUresult >(70);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_init(CUevent *arg0, CUipcEventHandle arg1) {
+    load_library();
+    return cuIpcOpenEventHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle_error(CUevent *, CUipcEventHandle) {
+    return on_init_failed<CUresult >(71);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_init(CUipcMemHandle *arg0, CUdeviceptr arg1) {
+    load_library();
+    return cuIpcGetMemHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle_error(CUipcMemHandle *, CUdeviceptr) {
+    return on_init_failed<CUresult >(72);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_v2_init(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    load_library();
+    return cuIpcOpenMemHandle_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_v2_error(CUdeviceptr *, CUipcMemHandle, unsigned int) {
+    return on_init_failed<CUresult >(73);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_init(CUdeviceptr arg0) {
+    load_library();
+    return cuIpcCloseMemHandle(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle_error(CUdeviceptr) {
+    return on_init_failed<CUresult >(74);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_init(void *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostRegister_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2_error(void *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(75);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_init(void *arg0) {
+    load_library();
+    return cuMemHostUnregister(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostUnregister_error(void *) {
+    return on_init_failed<CUresult >(76);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpy_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(77);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyPeer_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
+    return on_init_failed<CUresult >(78);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyHtoD_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds_error(CUdeviceptr, const void *, size_t) {
+    return on_init_failed<CUresult >(79);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoH_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds_error(void *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(80);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoD_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(81);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyDtoA_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds_error(CUarray, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(82);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoD_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds_error(CUdeviceptr, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(83);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyHtoA_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds_error(CUarray, size_t, const void *, size_t) {
+    return on_init_failed<CUresult >(84);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoH_v2_ptds(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds_error(void *, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(85);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyAtoA_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds_error(CUarray, size_t, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(86);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2D_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(87);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(88);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_init(const CUDA_MEMCPY3D *arg0) {
+    load_library();
+    return cuMemcpy3D_v2_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds_error(const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(89);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_init(const CUDA_MEMCPY3D_PEER *arg0) {
+    load_library();
+    return cuMemcpy3DPeer_ptds(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds_error(const CUDA_MEMCPY3D_PEER *) {
+    return on_init_failed<CUresult >(90);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(91);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemcpyPeerAsync_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
+    return on_init_failed<CUresult >(92);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz_error(CUdeviceptr, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(93);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz_error(void *, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(94);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync_v2_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(95);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz_error(CUarray, size_t, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(96);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync_v2_ptsz(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz_error(void *, CUarray, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(97);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz_error(const CUDA_MEMCPY2D *, CUstream) {
+    return on_init_failed<CUresult >(98);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz_error(const CUDA_MEMCPY3D *, CUstream) {
+    return on_init_failed<CUresult >(99);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DPeerAsync_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
+    return on_init_failed<CUresult >(100);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD8_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds_error(CUdeviceptr, unsigned char, size_t) {
+    return on_init_failed<CUresult >(101);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD16_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds_error(CUdeviceptr, unsigned short, size_t) {
+    return on_init_failed<CUresult >(102);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD32_v2_ptds(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds_error(CUdeviceptr, unsigned int, size_t) {
+    return on_init_failed<CUresult >(103);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D8_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
+    return on_init_failed<CUresult >(104);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D16_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
+    return on_init_failed<CUresult >(105);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D32_v2_ptds(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
+    return on_init_failed<CUresult >(106);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD8Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz_error(CUdeviceptr, unsigned char, size_t, CUstream) {
+    return on_init_failed<CUresult >(107);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD16Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz_error(CUdeviceptr, unsigned short, size_t, CUstream) {
+    return on_init_failed<CUresult >(108);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD32Async_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz_error(CUdeviceptr, unsigned int, size_t, CUstream) {
+    return on_init_failed<CUresult >(109);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D8Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(110);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D16Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(111);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D32Async_ptsz(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(112);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
+    load_library();
+    return cuArrayCreate_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_v2_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR *) {
+    return on_init_failed<CUresult >(113);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_init(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetDescriptor_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2_error(CUDA_ARRAY_DESCRIPTOR *, CUarray) {
+    return on_init_failed<CUresult >(114);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetSparseProperties_init(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetSparseProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetSparseProperties_error(CUDA_ARRAY_SPARSE_PROPERTIES *, CUarray) {
+    return on_init_failed<CUresult >(115);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetSparseProperties_init(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUmipmappedArray arg1) {
+    load_library();
+    return cuMipmappedArrayGetSparseProperties(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetSparseProperties_error(CUDA_ARRAY_SPARSE_PROPERTIES *, CUmipmappedArray) {
+    return on_init_failed<CUresult >(116);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetPlane_init(CUarray *arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuArrayGetPlane(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetPlane_error(CUarray *, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(117);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayDestroy_init(CUarray arg0) {
+    load_library();
+    return cuArrayDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayDestroy_error(CUarray) {
+    return on_init_failed<CUresult >(118);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
+    load_library();
+    return cuArray3DCreate_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *) {
+    return on_init_failed<CUresult >(119);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_init(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
+    load_library();
+    return cuArray3DGetDescriptor_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2_error(CUDA_ARRAY3D_DESCRIPTOR *, CUarray) {
+    return on_init_failed<CUresult >(120);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_init(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
+    load_library();
+    return cuMipmappedArrayCreate(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate_error(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int) {
+    return on_init_failed<CUresult >(121);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_init(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    load_library();
+    return cuMipmappedArrayGetLevel(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel_error(CUarray *, CUmipmappedArray, unsigned int) {
+    return on_init_failed<CUresult >(122);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_init(CUmipmappedArray arg0) {
+    load_library();
+    return cuMipmappedArrayDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy_error(CUmipmappedArray) {
+    return on_init_failed<CUresult >(123);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressReserve_init(CUdeviceptr *arg0, size_t arg1, size_t arg2, CUdeviceptr arg3, unsigned long long arg4) {
+    load_library();
+    return cuMemAddressReserve(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressReserve_error(CUdeviceptr *, size_t, size_t, CUdeviceptr, unsigned long long) {
+    return on_init_failed<CUresult >(124);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressFree_init(CUdeviceptr arg0, size_t arg1) {
+    load_library();
+    return cuMemAddressFree(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAddressFree_error(CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(125);
+}
+static CUresult _WRAPLIB_API_CALL cuMemCreate_init(CUmemGenericAllocationHandle *arg0, size_t arg1, const CUmemAllocationProp *arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemCreate_error(CUmemGenericAllocationHandle *, size_t, const CUmemAllocationProp *, unsigned long long) {
+    return on_init_failed<CUresult >(126);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRelease_init(CUmemGenericAllocationHandle arg0) {
+    load_library();
+    return cuMemRelease(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRelease_error(CUmemGenericAllocationHandle) {
+    return on_init_failed<CUresult >(127);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMap_init(CUdeviceptr arg0, size_t arg1, size_t arg2, CUmemGenericAllocationHandle arg3, unsigned long long arg4) {
+    load_library();
+    return cuMemMap(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMap_error(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long) {
+    return on_init_failed<CUresult >(128);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_ptsz_init(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    load_library();
+    return cuMemMapArrayAsync_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_ptsz_error(CUarrayMapInfo *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(129);
+}
+static CUresult _WRAPLIB_API_CALL cuMemUnmap_init(CUdeviceptr arg0, size_t arg1) {
+    load_library();
+    return cuMemUnmap(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemUnmap_error(CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(130);
+}
+static CUresult _WRAPLIB_API_CALL cuMemSetAccess_init(CUdeviceptr arg0, size_t arg1, const CUmemAccessDesc *arg2, size_t arg3) {
+    load_library();
+    return cuMemSetAccess(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemSetAccess_error(CUdeviceptr, size_t, const CUmemAccessDesc *, size_t) {
+    return on_init_failed<CUresult >(131);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAccess_init(unsigned long long *arg0, const CUmemLocation *arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuMemGetAccess(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAccess_error(unsigned long long *, const CUmemLocation *, CUdeviceptr) {
+    return on_init_failed<CUresult >(132);
+}
+static CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle_init(void *arg0, CUmemGenericAllocationHandle arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemExportToShareableHandle(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle_error(void *, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long) {
+    return on_init_failed<CUresult >(133);
+}
+static CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle_init(CUmemGenericAllocationHandle *arg0, void *arg1, CUmemAllocationHandleType arg2) {
+    load_library();
+    return cuMemImportFromShareableHandle(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle_error(CUmemGenericAllocationHandle *, void *, CUmemAllocationHandleType) {
+    return on_init_failed<CUresult >(134);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity_init(size_t *arg0, const CUmemAllocationProp *arg1, CUmemAllocationGranularity_flags arg2) {
+    load_library();
+    return cuMemGetAllocationGranularity(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity_error(size_t *, const CUmemAllocationProp *, CUmemAllocationGranularity_flags) {
+    return on_init_failed<CUresult >(135);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle_init(CUmemAllocationProp *arg0, CUmemGenericAllocationHandle arg1) {
+    load_library();
+    return cuMemGetAllocationPropertiesFromHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle_error(CUmemAllocationProp *, CUmemGenericAllocationHandle) {
+    return on_init_failed<CUresult >(136);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRetainAllocationHandle_init(CUmemGenericAllocationHandle *arg0, void *arg1) {
+    load_library();
+    return cuMemRetainAllocationHandle(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRetainAllocationHandle_error(CUmemGenericAllocationHandle *, void *) {
+    return on_init_failed<CUresult >(137);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeAsync_ptsz_init(CUdeviceptr arg0, CUstream arg1) {
+    load_library();
+    return cuMemFreeAsync_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeAsync_ptsz_error(CUdeviceptr, CUstream) {
+    return on_init_failed<CUresult >(138);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocAsync_ptsz_init(CUdeviceptr *arg0, size_t arg1, CUstream arg2) {
+    load_library();
+    return cuMemAllocAsync_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocAsync_ptsz_error(CUdeviceptr *, size_t, CUstream) {
+    return on_init_failed<CUresult >(139);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolTrimTo_init(CUmemoryPool arg0, size_t arg1) {
+    load_library();
+    return cuMemPoolTrimTo(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolTrimTo_error(CUmemoryPool, size_t) {
+    return on_init_failed<CUresult >(140);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolSetAttribute_init(CUmemoryPool arg0, CUmemPool_attribute arg1, void *arg2) {
+    load_library();
+    return cuMemPoolSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolSetAttribute_error(CUmemoryPool, CUmemPool_attribute, void *) {
+    return on_init_failed<CUresult >(141);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolGetAttribute_init(CUmemoryPool arg0, CUmemPool_attribute arg1, void *arg2) {
+    load_library();
+    return cuMemPoolGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolGetAttribute_error(CUmemoryPool, CUmemPool_attribute, void *) {
+    return on_init_failed<CUresult >(142);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolSetAccess_init(CUmemoryPool arg0, const CUmemAccessDesc *arg1, size_t arg2) {
+    load_library();
+    return cuMemPoolSetAccess(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolSetAccess_error(CUmemoryPool, const CUmemAccessDesc *, size_t) {
+    return on_init_failed<CUresult >(143);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolGetAccess_init(CUmemAccess_flags *arg0, CUmemoryPool arg1, CUmemLocation *arg2) {
+    load_library();
+    return cuMemPoolGetAccess(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolGetAccess_error(CUmemAccess_flags *, CUmemoryPool, CUmemLocation *) {
+    return on_init_failed<CUresult >(144);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolCreate_init(CUmemoryPool *arg0, const CUmemPoolProps *arg1) {
+    load_library();
+    return cuMemPoolCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolCreate_error(CUmemoryPool *, const CUmemPoolProps *) {
+    return on_init_failed<CUresult >(145);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolDestroy_init(CUmemoryPool arg0) {
+    load_library();
+    return cuMemPoolDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolDestroy_error(CUmemoryPool) {
+    return on_init_failed<CUresult >(146);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocFromPoolAsync_ptsz_init(CUdeviceptr *arg0, size_t arg1, CUmemoryPool arg2, CUstream arg3) {
+    load_library();
+    return cuMemAllocFromPoolAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocFromPoolAsync_ptsz_error(CUdeviceptr *, size_t, CUmemoryPool, CUstream) {
+    return on_init_failed<CUresult >(147);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolExportToShareableHandle_init(void *arg0, CUmemoryPool arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemPoolExportToShareableHandle(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolExportToShareableHandle_error(void *, CUmemoryPool, CUmemAllocationHandleType, unsigned long long) {
+    return on_init_failed<CUresult >(148);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolImportFromShareableHandle_init(CUmemoryPool *arg0, void *arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    load_library();
+    return cuMemPoolImportFromShareableHandle(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolImportFromShareableHandle_error(CUmemoryPool *, void *, CUmemAllocationHandleType, unsigned long long) {
+    return on_init_failed<CUresult >(149);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolExportPointer_init(CUmemPoolPtrExportData *arg0, CUdeviceptr arg1) {
+    load_library();
+    return cuMemPoolExportPointer(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolExportPointer_error(CUmemPoolPtrExportData *, CUdeviceptr) {
+    return on_init_failed<CUresult >(150);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolImportPointer_init(CUdeviceptr *arg0, CUmemoryPool arg1, CUmemPoolPtrExportData *arg2) {
+    load_library();
+    return cuMemPoolImportPointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPoolImportPointer_error(CUdeviceptr *, CUmemoryPool, CUmemPoolPtrExportData *) {
+    return on_init_failed<CUresult >(151);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_init(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuPointerGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttribute_error(void *, CUpointer_attribute, CUdeviceptr) {
+    return on_init_failed<CUresult >(152);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(153);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAdvise_init(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
+    load_library();
+    return cuMemAdvise(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAdvise_error(CUdeviceptr, size_t, CUmem_advise, CUdevice) {
+    return on_init_failed<CUresult >(154);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_init(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
+    load_library();
+    return cuMemRangeGetAttribute(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute_error(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(155);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_init(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
+    load_library();
+    return cuMemRangeGetAttributes(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes_error(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(156);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_init(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    load_library();
+    return cuPointerSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerSetAttribute_error(const void *, CUpointer_attribute, CUdeviceptr) {
+    return on_init_failed<CUresult >(157);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_init(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
+    load_library();
+    return cuPointerGetAttributes(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuPointerGetAttributes_error(unsigned int, CUpointer_attribute *, void **, CUdeviceptr) {
+    return on_init_failed<CUresult >(158);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreate_init(CUstream *arg0, unsigned int arg1) {
+    load_library();
+    return cuStreamCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreate_error(CUstream *, unsigned int) {
+    return on_init_failed<CUresult >(159);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_init(CUstream *arg0, unsigned int arg1, int arg2) {
+    load_library();
+    return cuStreamCreateWithPriority(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority_error(CUstream *, unsigned int, int) {
+    return on_init_failed<CUresult >(160);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_init(CUstream arg0, int *arg1) {
+    load_library();
+    return cuStreamGetPriority_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz_error(CUstream, int *) {
+    return on_init_failed<CUresult >(161);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_init(CUstream arg0, unsigned int *arg1) {
+    load_library();
+    return cuStreamGetFlags_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz_error(CUstream, unsigned int *) {
+    return on_init_failed<CUresult >(162);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(163);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    load_library();
+    return cuStreamWaitEvent_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz_error(CUstream, CUevent, unsigned int) {
+    return on_init_failed<CUresult >(164);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAddCallback_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz_error(CUstream, CUstreamCallback, void *, unsigned int) {
+    return on_init_failed<CUresult >(165);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(166);
+}
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_init(CUstreamCaptureMode *arg0) {
+    load_library();
+    return cuThreadExchangeStreamCaptureMode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode_error(CUstreamCaptureMode *) {
+    return on_init_failed<CUresult >(167);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(168);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(169);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(170);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(171);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(172);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamSynchronize_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(173);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_init(CUstream arg0) {
+    load_library();
+    return cuStreamDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2_error(CUstream) {
+    return on_init_failed<CUresult >(174);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_ptsz_init(CUstream arg0, CUstream arg1) {
+    load_library();
+    return cuStreamCopyAttributes_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_ptsz_error(CUstream, CUstream) {
+    return on_init_failed<CUresult >(175);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_ptsz_init(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamGetAttribute_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_ptsz_error(CUstream, CUstreamAttrID, CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(176);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_ptsz_init(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamSetAttribute_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_ptsz_error(CUstream, CUstreamAttrID, const CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(177);
+}
+static CUresult _WRAPLIB_API_CALL cuEventCreate_init(CUevent *arg0, unsigned int arg1) {
+    load_library();
+    return cuEventCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventCreate_error(CUevent *, unsigned int) {
+    return on_init_failed<CUresult >(178);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_init(CUevent arg0, CUstream arg1) {
+    load_library();
+    return cuEventRecord_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz_error(CUevent, CUstream) {
+    return on_init_failed<CUresult >(179);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_ptsz_init(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    load_library();
+    return cuEventRecordWithFlags_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_ptsz_error(CUevent, CUstream, unsigned int) {
+    return on_init_failed<CUresult >(180);
+}
+static CUresult _WRAPLIB_API_CALL cuEventQuery_init(CUevent arg0) {
+    load_library();
+    return cuEventQuery(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventQuery_error(CUevent) {
+    return on_init_failed<CUresult >(181);
+}
+static CUresult _WRAPLIB_API_CALL cuEventSynchronize_init(CUevent arg0) {
+    load_library();
+    return cuEventSynchronize(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventSynchronize_error(CUevent) {
+    return on_init_failed<CUresult >(182);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_init(CUevent arg0) {
+    load_library();
+    return cuEventDestroy_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_v2_error(CUevent) {
+    return on_init_failed<CUresult >(183);
+}
+static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_init(float *arg0, CUevent arg1, CUevent arg2) {
+    load_library();
+    return cuEventElapsedTime(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventElapsedTime_error(float *, CUevent, CUevent) {
+    return on_init_failed<CUresult >(184);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_init(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalMemory(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalMemory_error(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(185);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_init(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedBuffer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer_error(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *) {
+    return on_init_failed<CUresult >(186);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    load_library();
+    return cuExternalMemoryGetMappedMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray_error(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *) {
+    return on_init_failed<CUresult >(187);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_init(CUexternalMemory arg0) {
+    load_library();
+    return cuDestroyExternalMemory(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory_error(CUexternalMemory) {
+    return on_init_failed<CUresult >(188);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_init(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    load_library();
+    return cuImportExternalSemaphore(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore_error(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *) {
+    return on_init_failed<CUresult >(189);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(190);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(191);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_init(CUexternalSemaphore arg0) {
+    load_library();
+    return cuDestroyExternalSemaphore(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore_error(CUexternalSemaphore) {
+    return on_init_failed<CUresult >(192);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue32_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(193);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(194);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue32_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(195);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(196);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamBatchMemOp_ptsz(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
+    return on_init_failed<CUresult >(197);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_init(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
+    load_library();
+    return cuFuncGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetAttribute_error(int *, CUfunction_attribute, CUfunction) {
+    return on_init_failed<CUresult >(198);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_init(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    load_library();
+    return cuFuncSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetAttribute_error(CUfunction, CUfunction_attribute, int) {
+    return on_init_failed<CUresult >(199);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_init(CUfunction arg0, CUfunc_cache arg1) {
+    load_library();
+    return cuFuncSetCacheConfig(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig_error(CUfunction, CUfunc_cache) {
+    return on_init_failed<CUresult >(200);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_init(CUfunction arg0, CUsharedconfig arg1) {
+    load_library();
+    return cuFuncSetSharedMemConfig(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig_error(CUfunction, CUsharedconfig) {
+    return on_init_failed<CUresult >(201);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    load_library();
+    return cuLaunchKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
+    return on_init_failed<CUresult >(202);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel_ptsz(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(203);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_init(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuLaunchCooperativeKernelMultiDevice(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice_error(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(204);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(205);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_init(CUfunction arg0, int arg1, int arg2, int arg3) {
+    load_library();
+    return cuFuncSetBlockShape(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape_error(CUfunction, int, int, int) {
+    return on_init_failed<CUresult >(206);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_init(CUfunction arg0, unsigned int arg1) {
+    load_library();
+    return cuFuncSetSharedSize(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize_error(CUfunction, unsigned int) {
+    return on_init_failed<CUresult >(207);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetSize_init(CUfunction arg0, unsigned int arg1) {
+    load_library();
+    return cuParamSetSize(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetSize_error(CUfunction, unsigned int) {
+    return on_init_failed<CUresult >(208);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSeti_init(CUfunction arg0, int arg1, unsigned int arg2) {
+    load_library();
+    return cuParamSeti(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSeti_error(CUfunction, int, unsigned int) {
+    return on_init_failed<CUresult >(209);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetf_init(CUfunction arg0, int arg1, float arg2) {
+    load_library();
+    return cuParamSetf(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetf_error(CUfunction, int, float) {
+    return on_init_failed<CUresult >(210);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetv_init(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuParamSetv(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetv_error(CUfunction, int, void *, unsigned int) {
+    return on_init_failed<CUresult >(211);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunch_init(CUfunction arg0) {
+    load_library();
+    return cuLaunch(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunch_error(CUfunction) {
+    return on_init_failed<CUresult >(212);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGrid_init(CUfunction arg0, int arg1, int arg2) {
+    load_library();
+    return cuLaunchGrid(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGrid_error(CUfunction, int, int) {
+    return on_init_failed<CUresult >(213);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_init(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
+    load_library();
+    return cuLaunchGridAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchGridAsync_error(CUfunction, int, int, CUstream) {
+    return on_init_failed<CUresult >(214);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_init(CUfunction arg0, int arg1, CUtexref arg2) {
+    load_library();
+    return cuParamSetTexRef(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuParamSetTexRef_error(CUfunction, int, CUtexref) {
+    return on_init_failed<CUresult >(215);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_init(CUgraph *arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphCreate_error(CUgraph *, unsigned int) {
+    return on_init_failed<CUresult >(216);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddKernelNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(217);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_init(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams_error(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(218);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_init(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphKernelNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams_error(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(219);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemcpyNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(220);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_init(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams_error(CUgraphNode, CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(221);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    load_library();
+    return cuGraphMemcpyNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams_error(CUgraphNode, const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(222);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    load_library();
+    return cuGraphAddMemsetNode(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(223);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_init(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams_error(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(224);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_init(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphMemsetNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams_error(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(225);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddHostNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddHostNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(226);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_init(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams_error(CUgraphNode, CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(227);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_init(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphHostNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams_error(CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(228);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    load_library();
+    return cuGraphAddChildGraphNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph) {
+    return on_init_failed<CUresult >(229);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_init(CUgraphNode arg0, CUgraph *arg1) {
+    load_library();
+    return cuGraphChildGraphNodeGetGraph(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph_error(CUgraphNode, CUgraph *) {
+    return on_init_failed<CUresult >(230);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddEmptyNode(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(231);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventRecordNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    load_library();
+    return cuGraphAddEventRecordNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventRecordNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent) {
+    return on_init_failed<CUresult >(232);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeGetEvent_init(CUgraphNode arg0, CUevent *arg1) {
+    load_library();
+    return cuGraphEventRecordNodeGetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeGetEvent_error(CUgraphNode, CUevent *) {
+    return on_init_failed<CUresult >(233);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeSetEvent_init(CUgraphNode arg0, CUevent arg1) {
+    load_library();
+    return cuGraphEventRecordNodeSetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeSetEvent_error(CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(234);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventWaitNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    load_library();
+    return cuGraphAddEventWaitNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddEventWaitNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent) {
+    return on_init_failed<CUresult >(235);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeGetEvent_init(CUgraphNode arg0, CUevent *arg1) {
+    load_library();
+    return cuGraphEventWaitNodeGetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeGetEvent_error(CUgraphNode, CUevent *) {
+    return on_init_failed<CUresult >(236);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeSetEvent_init(CUgraphNode arg0, CUevent arg1) {
+    load_library();
+    return cuGraphEventWaitNodeSetEvent(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeSetEvent_error(CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(237);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddExternalSemaphoresSignalNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddExternalSemaphoresSignalNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddExternalSemaphoresSignalNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(238);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresSignalNodeGetParams_init(CUgraphNode arg0, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphExternalSemaphoresSignalNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresSignalNodeGetParams_error(CUgraphNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(239);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresSignalNodeSetParams_init(CUgraphNode arg0, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphExternalSemaphoresSignalNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresSignalNodeSetParams_error(CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(240);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddExternalSemaphoresWaitNode_init(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg4) {
+    load_library();
+    return cuGraphAddExternalSemaphoresWaitNode(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddExternalSemaphoresWaitNode_error(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(241);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresWaitNodeGetParams_init(CUgraphNode arg0, CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphExternalSemaphoresWaitNodeGetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresWaitNodeGetParams_error(CUgraphNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(242);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresWaitNodeSetParams_init(CUgraphNode arg0, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg1) {
+    load_library();
+    return cuGraphExternalSemaphoresWaitNodeSetParams(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresWaitNodeSetParams_error(CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(243);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_init(CUgraph *arg0, CUgraph arg1) {
+    load_library();
+    return cuGraphClone(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphClone_error(CUgraph *, CUgraph) {
+    return on_init_failed<CUresult >(244);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_init(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    load_library();
+    return cuGraphNodeFindInClone(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone_error(CUgraphNode *, CUgraphNode, CUgraph) {
+    return on_init_failed<CUresult >(245);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_init(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    load_library();
+    return cuGraphNodeGetType(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetType_error(CUgraphNode, CUgraphNodeType *) {
+    return on_init_failed<CUresult >(246);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(247);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_init(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphGetRootNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes_error(CUgraph, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(248);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_init(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    load_library();
+    return cuGraphGetEdges(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphGetEdges_error(CUgraph, CUgraphNode *, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(249);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependencies(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(250);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_init(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    load_library();
+    return cuGraphNodeGetDependentNodes(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes_error(CUgraphNode, CUgraphNode *, size_t *) {
+    return on_init_failed<CUresult >(251);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphAddDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphAddDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(252);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_init(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    load_library();
+    return cuGraphRemoveDependencies(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies_error(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t) {
+    return on_init_failed<CUresult >(253);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_init(CUgraphNode arg0) {
+    load_library();
+    return cuGraphDestroyNode(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroyNode_error(CUgraphNode) {
+    return on_init_failed<CUresult >(254);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_v2_init(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    load_library();
+    return cuGraphInstantiate_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_v2_error(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t) {
+    return on_init_failed<CUresult >(255);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecKernelNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(256);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMCPY3D *arg2, CUcontext arg3) {
+    load_library();
+    return cuGraphExecMemcpyNodeSetParams(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D *, CUcontext) {
+    return on_init_failed<CUresult >(257);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMSET_NODE_PARAMS *arg2, CUcontext arg3) {
+    load_library();
+    return cuGraphExecMemsetNodeSetParams(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *, CUcontext) {
+    return on_init_failed<CUresult >(258);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_HOST_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecHostNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(259);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecChildGraphNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, CUgraph arg2) {
+    load_library();
+    return cuGraphExecChildGraphNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecChildGraphNodeSetParams_error(CUgraphExec, CUgraphNode, CUgraph) {
+    return on_init_failed<CUresult >(260);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventRecordNodeSetEvent_init(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    load_library();
+    return cuGraphExecEventRecordNodeSetEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventRecordNodeSetEvent_error(CUgraphExec, CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(261);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventWaitNodeSetEvent_init(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    load_library();
+    return cuGraphExecEventWaitNodeSetEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecEventWaitNodeSetEvent_error(CUgraphExec, CUgraphNode, CUevent) {
+    return on_init_failed<CUresult >(262);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecExternalSemaphoresSignalNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecExternalSemaphoresSignalNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecExternalSemaphoresSignalNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(263);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecExternalSemaphoresWaitNodeSetParams_init(CUgraphExec arg0, CUgraphNode arg1, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg2) {
+    load_library();
+    return cuGraphExecExternalSemaphoresWaitNodeSetParams(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecExternalSemaphoresWaitNodeSetParams_error(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *) {
+    return on_init_failed<CUresult >(264);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_ptsz_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphUpload_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_ptsz_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(265);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch_ptsz(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(266);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_init(CUgraphExec arg0) {
+    load_library();
+    return cuGraphExecDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecDestroy_error(CUgraphExec) {
+    return on_init_failed<CUresult >(267);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_init(CUgraph arg0) {
+    load_library();
+    return cuGraphDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphDestroy_error(CUgraph) {
+    return on_init_failed<CUresult >(268);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecUpdate_init(CUgraphExec arg0, CUgraph arg1, CUgraphNode *arg2, CUgraphExecUpdateResult *arg3) {
+    load_library();
+    return cuGraphExecUpdate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphExecUpdate_error(CUgraphExec, CUgraph, CUgraphNode *, CUgraphExecUpdateResult *) {
+    return on_init_failed<CUresult >(269);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeCopyAttributes_init(CUgraphNode arg0, CUgraphNode arg1) {
+    load_library();
+    return cuGraphKernelNodeCopyAttributes(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeCopyAttributes_error(CUgraphNode, CUgraphNode) {
+    return on_init_failed<CUresult >(270);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetAttribute_init(CUgraphNode arg0, CUkernelNodeAttrID arg1, CUkernelNodeAttrValue *arg2) {
+    load_library();
+    return cuGraphKernelNodeGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetAttribute_error(CUgraphNode, CUkernelNodeAttrID, CUkernelNodeAttrValue *) {
+    return on_init_failed<CUresult >(271);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetAttribute_init(CUgraphNode arg0, CUkernelNodeAttrID arg1, const CUkernelNodeAttrValue *arg2) {
+    load_library();
+    return cuGraphKernelNodeSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetAttribute_error(CUgraphNode, CUkernelNodeAttrID, const CUkernelNodeAttrValue *) {
+    return on_init_failed<CUresult >(272);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_init(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
+    load_library();
+    return cuOccupancyMaxActiveBlocksPerMultiprocessor(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor_error(int *, CUfunction, int, size_t) {
+    return on_init_failed<CUresult >(273);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
+    load_library();
+    return cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error(int *, CUfunction, int, size_t, unsigned int) {
+    return on_init_failed<CUresult >(274);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
+    load_library();
+    return cuOccupancyMaxPotentialBlockSize(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int) {
+    return on_init_failed<CUresult >(275);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_init(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
+    load_library();
+    return cuOccupancyMaxPotentialBlockSizeWithFlags(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags_error(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int) {
+    return on_init_failed<CUresult >(276);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyAvailableDynamicSMemPerBlock_init(size_t *arg0, CUfunction arg1, int arg2, int arg3) {
+    load_library();
+    return cuOccupancyAvailableDynamicSMemPerBlock(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuOccupancyAvailableDynamicSMemPerBlock_error(size_t *, CUfunction, int, int) {
+    return on_init_failed<CUresult >(277);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_init(CUtexref arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuTexRefSetArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetArray_error(CUtexref, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(278);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_init(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    load_library();
+    return cuTexRefSetMipmappedArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray_error(CUtexref, CUmipmappedArray, unsigned int) {
+    return on_init_failed<CUresult >(279);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_init(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2_error(size_t *, CUtexref, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(280);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress2D_v3(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(281);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_init(CUtexref arg0, CUarray_format arg1, int arg2) {
+    load_library();
+    return cuTexRefSetFormat(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFormat_error(CUtexref, CUarray_format, int) {
+    return on_init_failed<CUresult >(282);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_init(CUtexref arg0, int arg1, CUaddress_mode arg2) {
+    load_library();
+    return cuTexRefSetAddressMode(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode_error(CUtexref, int, CUaddress_mode) {
+    return on_init_failed<CUresult >(283);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
+    load_library();
+    return cuTexRefSetFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode_error(CUtexref, CUfilter_mode) {
+    return on_init_failed<CUresult >(284);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_init(CUtexref arg0, CUfilter_mode arg1) {
+    load_library();
+    return cuTexRefSetMipmapFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode_error(CUtexref, CUfilter_mode) {
+    return on_init_failed<CUresult >(285);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_init(CUtexref arg0, float arg1) {
+    load_library();
+    return cuTexRefSetMipmapLevelBias(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias_error(CUtexref, float) {
+    return on_init_failed<CUresult >(286);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_init(CUtexref arg0, float arg1, float arg2) {
+    load_library();
+    return cuTexRefSetMipmapLevelClamp(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp_error(CUtexref, float, float) {
+    return on_init_failed<CUresult >(287);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_init(CUtexref arg0, unsigned int arg1) {
+    load_library();
+    return cuTexRefSetMaxAnisotropy(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy_error(CUtexref, unsigned int) {
+    return on_init_failed<CUresult >(288);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_init(CUtexref arg0, float *arg1) {
+    load_library();
+    return cuTexRefSetBorderColor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor_error(CUtexref, float *) {
+    return on_init_failed<CUresult >(289);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_init(CUtexref arg0, unsigned int arg1) {
+    load_library();
+    return cuTexRefSetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetFlags_error(CUtexref, unsigned int) {
+    return on_init_failed<CUresult >(290);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_init(CUdeviceptr *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetAddress_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2_error(CUdeviceptr *, CUtexref) {
+    return on_init_failed<CUresult >(291);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_init(CUarray *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetArray_error(CUarray *, CUtexref) {
+    return on_init_failed<CUresult >(292);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_init(CUmipmappedArray *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmappedArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray_error(CUmipmappedArray *, CUtexref) {
+    return on_init_failed<CUresult >(293);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_init(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
+    load_library();
+    return cuTexRefGetAddressMode(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode_error(CUaddress_mode *, CUtexref, int) {
+    return on_init_failed<CUresult >(294);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode_error(CUfilter_mode *, CUtexref) {
+    return on_init_failed<CUresult >(295);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_init(CUarray_format *arg0, int *arg1, CUtexref arg2) {
+    load_library();
+    return cuTexRefGetFormat(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFormat_error(CUarray_format *, int *, CUtexref) {
+    return on_init_failed<CUresult >(296);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_init(CUfilter_mode *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmapFilterMode(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode_error(CUfilter_mode *, CUtexref) {
+    return on_init_failed<CUresult >(297);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_init(float *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMipmapLevelBias(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias_error(float *, CUtexref) {
+    return on_init_failed<CUresult >(298);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_init(float *arg0, float *arg1, CUtexref arg2) {
+    load_library();
+    return cuTexRefGetMipmapLevelClamp(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp_error(float *, float *, CUtexref) {
+    return on_init_failed<CUresult >(299);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_init(int *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetMaxAnisotropy(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy_error(int *, CUtexref) {
+    return on_init_failed<CUresult >(300);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_init(float *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetBorderColor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor_error(float *, CUtexref) {
+    return on_init_failed<CUresult >(301);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_init(unsigned int *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetFlags_error(unsigned int *, CUtexref) {
+    return on_init_failed<CUresult >(302);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefCreate_init(CUtexref *arg0) {
+    load_library();
+    return cuTexRefCreate(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefCreate_error(CUtexref *) {
+    return on_init_failed<CUresult >(303);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_init(CUtexref arg0) {
+    load_library();
+    return cuTexRefDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefDestroy_error(CUtexref) {
+    return on_init_failed<CUresult >(304);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_init(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
+    load_library();
+    return cuSurfRefSetArray(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefSetArray_error(CUsurfref, CUarray, unsigned int) {
+    return on_init_failed<CUresult >(305);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_init(CUarray *arg0, CUsurfref arg1) {
+    load_library();
+    return cuSurfRefGetArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfRefGetArray_error(CUarray *, CUsurfref) {
+    return on_init_failed<CUresult >(306);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_init(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
+    load_library();
+    return cuTexObjectCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectCreate_error(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *) {
+    return on_init_failed<CUresult >(307);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_init(CUtexObject arg0) {
+    load_library();
+    return cuTexObjectDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectDestroy_error(CUtexObject) {
+    return on_init_failed<CUresult >(308);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetResourceDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(309);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_init(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetTextureDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc_error(CUDA_TEXTURE_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(310);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_init(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
+    load_library();
+    return cuTexObjectGetResourceViewDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc_error(CUDA_RESOURCE_VIEW_DESC *, CUtexObject) {
+    return on_init_failed<CUresult >(311);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_init(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
+    load_library();
+    return cuSurfObjectCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectCreate_error(CUsurfObject *, const CUDA_RESOURCE_DESC *) {
+    return on_init_failed<CUresult >(312);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_init(CUsurfObject arg0) {
+    load_library();
+    return cuSurfObjectDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy_error(CUsurfObject) {
+    return on_init_failed<CUresult >(313);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_init(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
+    load_library();
+    return cuSurfObjectGetResourceDesc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc_error(CUDA_RESOURCE_DESC *, CUsurfObject) {
+    return on_init_failed<CUresult >(314);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_init(int *arg0, CUdevice arg1, CUdevice arg2) {
+    load_library();
+    return cuDeviceCanAccessPeer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer_error(int *, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(315);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_init(CUcontext arg0, unsigned int arg1) {
+    load_library();
+    return cuCtxEnablePeerAccess(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess_error(CUcontext, unsigned int) {
+    return on_init_failed<CUresult >(316);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDisablePeerAccess(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess_error(CUcontext) {
+    return on_init_failed<CUresult >(317);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_init(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    load_library();
+    return cuDeviceGetP2PAttribute(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute_error(int *, CUdevice_P2PAttribute, CUdevice, CUdevice) {
+    return on_init_failed<CUresult >(318);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_init(CUgraphicsResource arg0) {
+    load_library();
+    return cuGraphicsUnregisterResource(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource_error(CUgraphicsResource) {
+    return on_init_failed<CUresult >(319);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_init(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuGraphicsSubResourceGetMappedArray(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray_error(CUarray *, CUgraphicsResource, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(320);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_init(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
+    load_library();
+    return cuGraphicsResourceGetMappedMipmappedArray(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray_error(CUmipmappedArray *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(321);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_init(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
+    load_library();
+    return cuGraphicsResourceGetMappedPointer_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2_error(CUdeviceptr *, size_t *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(322);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_init(CUgraphicsResource arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphicsResourceSetMapFlags_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2_error(CUgraphicsResource, unsigned int) {
+    return on_init_failed<CUresult >(323);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsMapResources_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(324);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsUnmapResources_ptsz(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(325);
+}
+static CUresult _WRAPLIB_API_CALL cuGetExportTable_init(const void **arg0, const CUuuid *arg1) {
+    load_library();
+    return cuGetExportTable(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGetExportTable_error(const void **, const CUuuid *) {
+    return on_init_failed<CUresult >(326);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetModule_init(CUmodule *arg0, CUfunction arg1) {
+    load_library();
+    return cuFuncGetModule(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuFuncGetModule_error(CUmodule *, CUfunction) {
+    return on_init_failed<CUresult >(327);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_init(void *arg0, size_t arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostRegister(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostRegister_error(void *, size_t, unsigned int) {
+    return on_init_failed<CUresult >(328);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_init(CUgraphicsResource arg0, unsigned int arg1) {
+    load_library();
+    return cuGraphicsResourceSetMapFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_error(CUgraphicsResource, unsigned int) {
+    return on_init_failed<CUresult >(329);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_init(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    load_library();
+    return cuLinkCreate(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkCreate_error(unsigned int, CUjit_option *, void **, CUlinkState *) {
+    return on_init_failed<CUresult >(330);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_init(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    load_library();
+    return cuLinkAddData(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddData_error(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(331);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_init(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    load_library();
+    return cuLinkAddFile(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuLinkAddFile_error(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **) {
+    return on_init_failed<CUresult >(332);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuTexRefSetAddress2D_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(333);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_init(unsigned int *arg0, CUdevice arg1) {
+    load_library();
+    return cuDeviceTotalMem(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_error(unsigned int *, CUdevice) {
+    return on_init_failed<CUresult >(334);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_init(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    load_library();
+    return cuCtxCreate(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxCreate_error(CUcontext *, unsigned int, CUdevice) {
+    return on_init_failed<CUresult >(335);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
+    load_library();
+    return cuModuleGetGlobal(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_error(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *) {
+    return on_init_failed<CUresult >(336);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_init(unsigned int *arg0, unsigned int *arg1) {
+    load_library();
+    return cuMemGetInfo(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetInfo_error(unsigned int *, unsigned int *) {
+    return on_init_failed<CUresult >(337);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_init(CUdeviceptr_v1 *arg0, unsigned int arg1) {
+    load_library();
+    return cuMemAlloc(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAlloc_error(CUdeviceptr_v1 *, unsigned int) {
+    return on_init_failed<CUresult >(338);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemAllocPitch(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocPitch_error(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(339);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_init(CUdeviceptr_v1 arg0) {
+    load_library();
+    return cuMemFree(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFree_error(CUdeviceptr_v1) {
+    return on_init_failed<CUresult >(340);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
+    load_library();
+    return cuMemGetAddressRange(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_error(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1) {
+    return on_init_failed<CUresult >(341);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_init(void **arg0, unsigned int arg1) {
+    load_library();
+    return cuMemAllocHost(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocHost_error(void **, unsigned int) {
+    return on_init_failed<CUresult >(342);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_init(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemHostGetDevicePointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_error(CUdeviceptr_v1 *, void *, unsigned int) {
+    return on_init_failed<CUresult >(343);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyHtoD(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_error(CUdeviceptr_v1, const void *, unsigned int) {
+    return on_init_failed<CUresult >(344);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyDtoH(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_error(void *, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(345);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    load_library();
+    return cuMemcpyDtoD(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(346);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_init(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyDtoA(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_error(CUarray, unsigned int, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(347);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_init(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyAtoD(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_error(CUdeviceptr_v1, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(348);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyHtoA(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_error(CUarray, unsigned int, const void *, unsigned int) {
+    return on_init_failed<CUresult >(349);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    load_library();
+    return cuMemcpyAtoH(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_error(void *, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(350);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_init(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemcpyAtoA(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_error(CUarray, unsigned int, CUarray, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(351);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_init(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_error(CUarray, unsigned int, const void *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(352);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_init(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_error(void *, CUarray, unsigned int, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(353);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_init(const CUDA_MEMCPY2D_v1 *arg0) {
+    load_library();
+    return cuMemcpy2D(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_error(const CUDA_MEMCPY2D_v1 *) {
+    return on_init_failed<CUresult >(354);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_init(const CUDA_MEMCPY2D_v1 *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_error(const CUDA_MEMCPY2D_v1 *) {
+    return on_init_failed<CUresult >(355);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_init(const CUDA_MEMCPY3D_v1 *arg0) {
+    load_library();
+    return cuMemcpy3D(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_error(const CUDA_MEMCPY3D_v1 *) {
+    return on_init_failed<CUresult >(356);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_init(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_error(CUdeviceptr_v1, const void *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(357);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_init(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_error(void *, CUdeviceptr_v1, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(358);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_init(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_error(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(359);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_init(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_error(const CUDA_MEMCPY2D_v1 *, CUstream) {
+    return on_init_failed<CUresult >(360);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_init(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_error(const CUDA_MEMCPY3D_v1 *, CUstream) {
+    return on_init_failed<CUresult >(361);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_init(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD8(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_error(CUdeviceptr_v1, unsigned char, unsigned int) {
+    return on_init_failed<CUresult >(362);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_init(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD16(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_error(CUdeviceptr_v1, unsigned short, unsigned int) {
+    return on_init_failed<CUresult >(363);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
+    load_library();
+    return cuMemsetD32(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_error(CUdeviceptr_v1, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(364);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D8(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_error(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(365);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D16(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_error(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(366);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_init(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    load_library();
+    return cuMemsetD2D32(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_error(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int) {
+    return on_init_failed<CUresult >(367);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_init(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
+    load_library();
+    return cuArrayCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayCreate_error(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *) {
+    return on_init_failed<CUresult >(368);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_init(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    load_library();
+    return cuArrayGetDescriptor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_error(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray) {
+    return on_init_failed<CUresult >(369);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_init(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
+    load_library();
+    return cuArray3DCreate(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DCreate_error(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *) {
+    return on_init_failed<CUresult >(370);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_init(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    load_library();
+    return cuArray3DGetDescriptor(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_error(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray) {
+    return on_init_failed<CUresult >(371);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_init(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuTexRefSetAddress(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_error(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(372);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_init(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    load_library();
+    return cuTexRefSetAddress2D(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_error(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int) {
+    return on_init_failed<CUresult >(373);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_init(CUdeviceptr_v1 *arg0, CUtexref arg1) {
+    load_library();
+    return cuTexRefGetAddress(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_error(CUdeviceptr_v1 *, CUtexref) {
+    return on_init_failed<CUresult >(374);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_init(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
+    load_library();
+    return cuGraphicsResourceGetMappedPointer(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_error(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource) {
+    return on_init_failed<CUresult >(375);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_init(CUcontext arg0) {
+    load_library();
+    return cuCtxDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxDestroy_error(CUcontext) {
+    return on_init_failed<CUresult >(376);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_init(CUcontext *arg0) {
+    load_library();
+    return cuCtxPopCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_error(CUcontext *) {
+    return on_init_failed<CUresult >(377);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_init(CUcontext arg0) {
+    load_library();
+    return cuCtxPushCurrent(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_error(CUcontext) {
+    return on_init_failed<CUresult >(378);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_init(CUstream arg0) {
+    load_library();
+    return cuStreamDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamDestroy_error(CUstream) {
+    return on_init_failed<CUresult >(379);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_init(CUevent arg0) {
+    load_library();
+    return cuEventDestroy(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuEventDestroy_error(CUevent) {
+    return on_init_failed<CUresult >(380);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxRelease(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_error(CUdevice) {
+    return on_init_failed<CUresult >(381);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_init(CUdevice arg0) {
+    load_library();
+    return cuDevicePrimaryCtxReset(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_error(CUdevice) {
+    return on_init_failed<CUresult >(382);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_init(CUdevice arg0, unsigned int arg1) {
+    load_library();
+    return cuDevicePrimaryCtxSetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_error(CUdevice, unsigned int) {
+    return on_init_failed<CUresult >(383);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyHtoD_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_error(CUdeviceptr, const void *, size_t) {
+    return on_init_failed<CUresult >(384);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoH_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_error(void *, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(385);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpyDtoD_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(386);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_init(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyDtoA_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_error(CUarray, size_t, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(387);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_init(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoD_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_error(CUdeviceptr, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(388);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyHtoA_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_error(CUarray, size_t, const void *, size_t) {
+    return on_init_failed<CUresult >(389);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    load_library();
+    return cuMemcpyAtoH_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_error(void *, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(390);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_init(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyAtoA_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_error(CUarray, size_t, CUarray, size_t, size_t) {
+    return on_init_failed<CUresult >(391);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_init(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyHtoAAsync_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_error(CUarray, size_t, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(392);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_init(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    load_library();
+    return cuMemcpyAtoHAsync_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_error(void *, CUarray, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(393);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2D_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(394);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_init(const CUDA_MEMCPY2D *arg0) {
+    load_library();
+    return cuMemcpy2DUnaligned_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_error(const CUDA_MEMCPY2D *) {
+    return on_init_failed<CUresult >(395);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_init(const CUDA_MEMCPY3D *arg0) {
+    load_library();
+    return cuMemcpy3D_v2(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_error(const CUDA_MEMCPY3D *) {
+    return on_init_failed<CUresult >(396);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_init(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyHtoDAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_error(CUdeviceptr, const void *, size_t, CUstream) {
+    return on_init_failed<CUresult >(397);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_init(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoHAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_error(void *, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(398);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyDtoDAsync_v2(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(399);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_init(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy2DAsync_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_error(const CUDA_MEMCPY2D *, CUstream) {
+    return on_init_failed<CUresult >(400);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_init(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DAsync_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_error(const CUDA_MEMCPY3D *, CUstream) {
+    return on_init_failed<CUresult >(401);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD8_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_error(CUdeviceptr, unsigned char, size_t) {
+    return on_init_failed<CUresult >(402);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD16_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_error(CUdeviceptr, unsigned short, size_t) {
+    return on_init_failed<CUresult >(403);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    load_library();
+    return cuMemsetD32_v2(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_error(CUdeviceptr, unsigned int, size_t) {
+    return on_init_failed<CUresult >(404);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D8_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_error(CUdeviceptr, size_t, unsigned char, size_t, size_t) {
+    return on_init_failed<CUresult >(405);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D16_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_error(CUdeviceptr, size_t, unsigned short, size_t, size_t) {
+    return on_init_failed<CUresult >(406);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    load_library();
+    return cuMemsetD2D32_v2(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_error(CUdeviceptr, size_t, unsigned int, size_t, size_t) {
+    return on_init_failed<CUresult >(407);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    load_library();
+    return cuMemcpy(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy_error(CUdeviceptr, CUdeviceptr, size_t) {
+    return on_init_failed<CUresult >(408);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_init(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemcpyAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyAsync_error(CUdeviceptr, CUdeviceptr, size_t, CUstream) {
+    return on_init_failed<CUresult >(409);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    load_library();
+    return cuMemcpyPeer(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeer_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) {
+    return on_init_failed<CUresult >(410);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_init(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemcpyPeerAsync(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_error(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) {
+    return on_init_failed<CUresult >(411);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_init(const CUDA_MEMCPY3D_PEER *arg0) {
+    load_library();
+    return cuMemcpy3DPeer(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_error(const CUDA_MEMCPY3D_PEER *) {
+    return on_init_failed<CUresult >(412);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_init(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    load_library();
+    return cuMemcpy3DPeerAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_error(const CUDA_MEMCPY3D_PEER *, CUstream) {
+    return on_init_failed<CUresult >(413);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_init(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD8Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD8Async_error(CUdeviceptr, unsigned char, size_t, CUstream) {
+    return on_init_failed<CUresult >(414);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_init(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD16Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD16Async_error(CUdeviceptr, unsigned short, size_t, CUstream) {
+    return on_init_failed<CUresult >(415);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_init(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    load_library();
+    return cuMemsetD32Async(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD32Async_error(CUdeviceptr, unsigned int, size_t, CUstream) {
+    return on_init_failed<CUresult >(416);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_init(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D8Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_error(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(417);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_init(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D16Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_error(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(418);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_init(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    load_library();
+    return cuMemsetD2D32Async(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_error(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) {
+    return on_init_failed<CUresult >(419);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_init(CUstream arg0, int *arg1) {
+    load_library();
+    return cuStreamGetPriority(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetPriority_error(CUstream, int *) {
+    return on_init_failed<CUresult >(420);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_init(CUstream arg0, unsigned int *arg1) {
+    load_library();
+    return cuStreamGetFlags(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetFlags_error(CUstream, unsigned int *) {
+    return on_init_failed<CUresult >(421);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_init(CUstream arg0, CUcontext *arg1) {
+    load_library();
+    return cuStreamGetCtx(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCtx_error(CUstream, CUcontext *) {
+    return on_init_failed<CUresult >(422);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_init(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    load_library();
+    return cuStreamWaitEvent(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_error(CUstream, CUevent, unsigned int) {
+    return on_init_failed<CUresult >(423);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_init(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAddCallback(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAddCallback_error(CUstream, CUstreamCallback, void *, unsigned int) {
+    return on_init_failed<CUresult >(424);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_init(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamAttachMemAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_error(CUstream, CUdeviceptr, size_t, unsigned int) {
+    return on_init_failed<CUresult >(425);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_init(CUstream arg0) {
+    load_library();
+    return cuStreamQuery(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamQuery_error(CUstream) {
+    return on_init_failed<CUresult >(426);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_init(CUstream arg0) {
+    load_library();
+    return cuStreamSynchronize(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSynchronize_error(CUstream) {
+    return on_init_failed<CUresult >(427);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_init(CUevent arg0, CUstream arg1) {
+    load_library();
+    return cuEventRecord(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecord_error(CUevent, CUstream) {
+    return on_init_failed<CUresult >(428);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_init(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    load_library();
+    return cuEventRecordWithFlags(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_error(CUevent, CUstream, unsigned int) {
+    return on_init_failed<CUresult >(429);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    load_library();
+    return cuLaunchKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **) {
+    return on_init_failed<CUresult >(430);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_init(CUstream arg0, CUhostFn arg1, void *arg2) {
+    load_library();
+    return cuLaunchHostFunc(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_error(CUstream, CUhostFn, void *) {
+    return on_init_failed<CUresult >(431);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsMapResources(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(432);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_init(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    load_library();
+    return cuGraphicsUnmapResources(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_error(unsigned int, CUgraphicsResource *, CUstream) {
+    return on_init_failed<CUresult >(433);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue32(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(434);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_init(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue32(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_error(CUstream, CUdeviceptr, cuuint32_t, unsigned int) {
+    return on_init_failed<CUresult >(435);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWriteValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(436);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_init(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamWaitValue64(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_error(CUstream, CUdeviceptr, cuuint64_t, unsigned int) {
+    return on_init_failed<CUresult >(437);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_init(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    load_library();
+    return cuStreamBatchMemOp(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_error(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int) {
+    return on_init_failed<CUresult >(438);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_init(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    load_library();
+    return cuMemPrefetchAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_error(CUdeviceptr, size_t, CUdevice, CUstream) {
+    return on_init_failed<CUresult >(439);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_init(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    load_library();
+    return cuLaunchCooperativeKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+static CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_error(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **) {
+    return on_init_failed<CUresult >(440);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuSignalExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(441);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_init(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    load_library();
+    return cuWaitExternalSemaphoresAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_error(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(442);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_error(CUstream) {
+    return on_init_failed<CUresult >(443);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_init(CUstream arg0) {
+    load_library();
+    return cuStreamBeginCapture_ptsz(arg0);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz_error(CUstream) {
+    return on_init_failed<CUresult >(444);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_init(CUstream arg0, CUstreamCaptureMode arg1) {
+    load_library();
+    return cuStreamBeginCapture_v2(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_error(CUstream, CUstreamCaptureMode) {
+    return on_init_failed<CUresult >(445);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_init(CUstream arg0, CUgraph *arg1) {
+    load_library();
+    return cuStreamEndCapture(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamEndCapture_error(CUstream, CUgraph *) {
+    return on_init_failed<CUresult >(446);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_init(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    load_library();
+    return cuStreamIsCapturing(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_error(CUstream, CUstreamCaptureStatus *) {
+    return on_init_failed<CUresult >(447);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_init(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    load_library();
+    return cuStreamGetCaptureInfo(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_error(CUstream, CUstreamCaptureStatus *, cuuint64_t *) {
+    return on_init_failed<CUresult >(448);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphUpload(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphUpload_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(449);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_init(CUgraphExec arg0, CUstream arg1) {
+    load_library();
+    return cuGraphLaunch(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphLaunch_error(CUgraphExec, CUstream) {
+    return on_init_failed<CUresult >(450);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_init(CUstream arg0, CUstream arg1) {
+    load_library();
+    return cuStreamCopyAttributes(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_error(CUstream, CUstream) {
+    return on_init_failed<CUresult >(451);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_init(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamGetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_error(CUstream, CUstreamAttrID, CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(452);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_init(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    load_library();
+    return cuStreamSetAttribute(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_error(CUstream, CUstreamAttrID, const CUstreamAttrValue *) {
+    return on_init_failed<CUresult >(453);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_init(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    load_library();
+    return cuIpcOpenMemHandle(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_error(CUdeviceptr *, CUipcMemHandle, unsigned int) {
+    return on_init_failed<CUresult >(454);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_init(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    load_library();
+    return cuGraphInstantiate(arg0, arg1, arg2, arg3, arg4);
+}
+static CUresult _WRAPLIB_API_CALL cuGraphInstantiate_error(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t) {
+    return on_init_failed<CUresult >(455);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_init(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    load_library();
+    return cuMemMapArrayAsync(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_error(CUarrayMapInfo *, unsigned int, CUstream) {
+    return on_init_failed<CUresult >(456);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeAsync_init(CUdeviceptr arg0, CUstream arg1) {
+    load_library();
+    return cuMemFreeAsync(arg0, arg1);
+}
+static CUresult _WRAPLIB_API_CALL cuMemFreeAsync_error(CUdeviceptr, CUstream) {
+    return on_init_failed<CUresult >(457);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocAsync_init(CUdeviceptr *arg0, size_t arg1, CUstream arg2) {
+    load_library();
+    return cuMemAllocAsync(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocAsync_error(CUdeviceptr *, size_t, CUstream) {
+    return on_init_failed<CUresult >(458);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocFromPoolAsync_init(CUdeviceptr *arg0, size_t arg1, CUmemoryPool arg2, CUstream arg3) {
+    load_library();
+    return cuMemAllocFromPoolAsync(arg0, arg1, arg2, arg3);
+}
+static CUresult _WRAPLIB_API_CALL cuMemAllocFromPoolAsync_error(CUdeviceptr *, size_t, CUmemoryPool, CUstream) {
+    return on_init_failed<CUresult >(459);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_init(const char *arg0, const char *arg1, CUoutput_mode arg2) {
+    load_library();
+    return cuProfilerInitialize(arg0, arg1, arg2);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerInitialize_error(const char *, const char *, CUoutput_mode) {
+    return on_init_failed<CUresult >(460);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStart_init() {
+    load_library();
+    return cuProfilerStart();
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStart_error() {
+    return on_init_failed<CUresult >(461);
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStop_init() {
+    load_library();
+    return cuProfilerStop();
+}
+static CUresult _WRAPLIB_API_CALL cuProfilerStop_error() {
+    return on_init_failed<CUresult >(462);
+}
+static constexpr size_t NR_FUNC = 463;
+static void* g_func_table[NR_FUNC] = {(void*)(&cuGetErrorString_init),
+    (void*)(&cuGetErrorName_init),
+    (void*)(&cuInit_init),
+    (void*)(&cuDriverGetVersion_init),
+    (void*)(&cuDeviceGet_init),
+    (void*)(&cuDeviceGetCount_init),
+    (void*)(&cuDeviceGetName_init),
+    (void*)(&cuDeviceGetUuid_init),
+    (void*)(&cuDeviceGetLuid_init),
+    (void*)(&cuDeviceTotalMem_v2_init),
+    (void*)(&cuDeviceGetTexture1DLinearMaxWidth_init),
+    (void*)(&cuDeviceGetAttribute_init),
+    (void*)(&cuDeviceGetNvSciSyncAttributes_init),
+    (void*)(&cuDeviceSetMemPool_init),
+    (void*)(&cuDeviceGetMemPool_init),
+    (void*)(&cuDeviceGetDefaultMemPool_init),
+    (void*)(&cuDeviceGetProperties_init),
+    (void*)(&cuDeviceComputeCapability_init),
+    (void*)(&cuDevicePrimaryCtxRetain_init),
+    (void*)(&cuDevicePrimaryCtxRelease_v2_init),
+    (void*)(&cuDevicePrimaryCtxSetFlags_v2_init),
+    (void*)(&cuDevicePrimaryCtxGetState_init),
+    (void*)(&cuDevicePrimaryCtxReset_v2_init),
+    (void*)(&cuCtxCreate_v2_init),
+    (void*)(&cuCtxDestroy_v2_init),
+    (void*)(&cuCtxPushCurrent_v2_init),
+    (void*)(&cuCtxPopCurrent_v2_init),
+    (void*)(&cuCtxSetCurrent_init),
+    (void*)(&cuCtxGetCurrent_init),
+    (void*)(&cuCtxGetDevice_init),
+    (void*)(&cuCtxGetFlags_init),
+    (void*)(&cuCtxSynchronize_init),
+    (void*)(&cuCtxSetLimit_init),
+    (void*)(&cuCtxGetLimit_init),
+    (void*)(&cuCtxGetCacheConfig_init),
+    (void*)(&cuCtxSetCacheConfig_init),
+    (void*)(&cuCtxGetSharedMemConfig_init),
+    (void*)(&cuCtxSetSharedMemConfig_init),
+    (void*)(&cuCtxGetApiVersion_init),
+    (void*)(&cuCtxGetStreamPriorityRange_init),
+    (void*)(&cuCtxResetPersistingL2Cache_init),
+    (void*)(&cuCtxAttach_init),
+    (void*)(&cuCtxDetach_init),
+    (void*)(&cuModuleLoad_init),
+    (void*)(&cuModuleLoadData_init),
+    (void*)(&cuModuleLoadDataEx_init),
+    (void*)(&cuModuleLoadFatBinary_init),
+    (void*)(&cuModuleUnload_init),
+    (void*)(&cuModuleGetFunction_init),
+    (void*)(&cuModuleGetGlobal_v2_init),
+    (void*)(&cuModuleGetTexRef_init),
+    (void*)(&cuModuleGetSurfRef_init),
+    (void*)(&cuLinkCreate_v2_init),
+    (void*)(&cuLinkAddData_v2_init),
+    (void*)(&cuLinkAddFile_v2_init),
+    (void*)(&cuLinkComplete_init),
+    (void*)(&cuLinkDestroy_init),
+    (void*)(&cuMemGetInfo_v2_init),
+    (void*)(&cuMemAlloc_v2_init),
+    (void*)(&cuMemAllocPitch_v2_init),
+    (void*)(&cuMemFree_v2_init),
+    (void*)(&cuMemGetAddressRange_v2_init),
+    (void*)(&cuMemAllocHost_v2_init),
+    (void*)(&cuMemFreeHost_init),
+    (void*)(&cuMemHostAlloc_init),
+    (void*)(&cuMemHostGetDevicePointer_v2_init),
+    (void*)(&cuMemHostGetFlags_init),
+    (void*)(&cuMemAllocManaged_init),
+    (void*)(&cuDeviceGetByPCIBusId_init),
+    (void*)(&cuDeviceGetPCIBusId_init),
+    (void*)(&cuIpcGetEventHandle_init),
+    (void*)(&cuIpcOpenEventHandle_init),
+    (void*)(&cuIpcGetMemHandle_init),
+    (void*)(&cuIpcOpenMemHandle_v2_init),
+    (void*)(&cuIpcCloseMemHandle_init),
+    (void*)(&cuMemHostRegister_v2_init),
+    (void*)(&cuMemHostUnregister_init),
+    (void*)(&cuMemcpy_ptds_init),
+    (void*)(&cuMemcpyPeer_ptds_init),
+    (void*)(&cuMemcpyHtoD_v2_ptds_init),
+    (void*)(&cuMemcpyDtoH_v2_ptds_init),
+    (void*)(&cuMemcpyDtoD_v2_ptds_init),
+    (void*)(&cuMemcpyDtoA_v2_ptds_init),
+    (void*)(&cuMemcpyAtoD_v2_ptds_init),
+    (void*)(&cuMemcpyHtoA_v2_ptds_init),
+    (void*)(&cuMemcpyAtoH_v2_ptds_init),
+    (void*)(&cuMemcpyAtoA_v2_ptds_init),
+    (void*)(&cuMemcpy2D_v2_ptds_init),
+    (void*)(&cuMemcpy2DUnaligned_v2_ptds_init),
+    (void*)(&cuMemcpy3D_v2_ptds_init),
+    (void*)(&cuMemcpy3DPeer_ptds_init),
+    (void*)(&cuMemcpyAsync_ptsz_init),
+    (void*)(&cuMemcpyPeerAsync_ptsz_init),
+    (void*)(&cuMemcpyHtoDAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyDtoHAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyDtoDAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyHtoAAsync_v2_ptsz_init),
+    (void*)(&cuMemcpyAtoHAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy2DAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy3DAsync_v2_ptsz_init),
+    (void*)(&cuMemcpy3DPeerAsync_ptsz_init),
+    (void*)(&cuMemsetD8_v2_ptds_init),
+    (void*)(&cuMemsetD16_v2_ptds_init),
+    (void*)(&cuMemsetD32_v2_ptds_init),
+    (void*)(&cuMemsetD2D8_v2_ptds_init),
+    (void*)(&cuMemsetD2D16_v2_ptds_init),
+    (void*)(&cuMemsetD2D32_v2_ptds_init),
+    (void*)(&cuMemsetD8Async_ptsz_init),
+    (void*)(&cuMemsetD16Async_ptsz_init),
+    (void*)(&cuMemsetD32Async_ptsz_init),
+    (void*)(&cuMemsetD2D8Async_ptsz_init),
+    (void*)(&cuMemsetD2D16Async_ptsz_init),
+    (void*)(&cuMemsetD2D32Async_ptsz_init),
+    (void*)(&cuArrayCreate_v2_init),
+    (void*)(&cuArrayGetDescriptor_v2_init),
+    (void*)(&cuArrayGetSparseProperties_init),
+    (void*)(&cuMipmappedArrayGetSparseProperties_init),
+    (void*)(&cuArrayGetPlane_init),
+    (void*)(&cuArrayDestroy_init),
+    (void*)(&cuArray3DCreate_v2_init),
+    (void*)(&cuArray3DGetDescriptor_v2_init),
+    (void*)(&cuMipmappedArrayCreate_init),
+    (void*)(&cuMipmappedArrayGetLevel_init),
+    (void*)(&cuMipmappedArrayDestroy_init),
+    (void*)(&cuMemAddressReserve_init),
+    (void*)(&cuMemAddressFree_init),
+    (void*)(&cuMemCreate_init),
+    (void*)(&cuMemRelease_init),
+    (void*)(&cuMemMap_init),
+    (void*)(&cuMemMapArrayAsync_ptsz_init),
+    (void*)(&cuMemUnmap_init),
+    (void*)(&cuMemSetAccess_init),
+    (void*)(&cuMemGetAccess_init),
+    (void*)(&cuMemExportToShareableHandle_init),
+    (void*)(&cuMemImportFromShareableHandle_init),
+    (void*)(&cuMemGetAllocationGranularity_init),
+    (void*)(&cuMemGetAllocationPropertiesFromHandle_init),
+    (void*)(&cuMemRetainAllocationHandle_init),
+    (void*)(&cuMemFreeAsync_ptsz_init),
+    (void*)(&cuMemAllocAsync_ptsz_init),
+    (void*)(&cuMemPoolTrimTo_init),
+    (void*)(&cuMemPoolSetAttribute_init),
+    (void*)(&cuMemPoolGetAttribute_init),
+    (void*)(&cuMemPoolSetAccess_init),
+    (void*)(&cuMemPoolGetAccess_init),
+    (void*)(&cuMemPoolCreate_init),
+    (void*)(&cuMemPoolDestroy_init),
+    (void*)(&cuMemAllocFromPoolAsync_ptsz_init),
+    (void*)(&cuMemPoolExportToShareableHandle_init),
+    (void*)(&cuMemPoolImportFromShareableHandle_init),
+    (void*)(&cuMemPoolExportPointer_init),
+    (void*)(&cuMemPoolImportPointer_init),
+    (void*)(&cuPointerGetAttribute_init),
+    (void*)(&cuMemPrefetchAsync_ptsz_init),
+    (void*)(&cuMemAdvise_init),
+    (void*)(&cuMemRangeGetAttribute_init),
+    (void*)(&cuMemRangeGetAttributes_init),
+    (void*)(&cuPointerSetAttribute_init),
+    (void*)(&cuPointerGetAttributes_init),
+    (void*)(&cuStreamCreate_init),
+    (void*)(&cuStreamCreateWithPriority_init),
+    (void*)(&cuStreamGetPriority_ptsz_init),
+    (void*)(&cuStreamGetFlags_ptsz_init),
+    (void*)(&cuStreamGetCtx_ptsz_init),
+    (void*)(&cuStreamWaitEvent_ptsz_init),
+    (void*)(&cuStreamAddCallback_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_init),
+    (void*)(&cuThreadExchangeStreamCaptureMode_init),
+    (void*)(&cuStreamEndCapture_ptsz_init),
+    (void*)(&cuStreamIsCapturing_ptsz_init),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_init),
+    (void*)(&cuStreamAttachMemAsync_ptsz_init),
+    (void*)(&cuStreamQuery_ptsz_init),
+    (void*)(&cuStreamSynchronize_ptsz_init),
+    (void*)(&cuStreamDestroy_v2_init),
+    (void*)(&cuStreamCopyAttributes_ptsz_init),
+    (void*)(&cuStreamGetAttribute_ptsz_init),
+    (void*)(&cuStreamSetAttribute_ptsz_init),
+    (void*)(&cuEventCreate_init),
+    (void*)(&cuEventRecord_ptsz_init),
+    (void*)(&cuEventRecordWithFlags_ptsz_init),
+    (void*)(&cuEventQuery_init),
+    (void*)(&cuEventSynchronize_init),
+    (void*)(&cuEventDestroy_v2_init),
+    (void*)(&cuEventElapsedTime_init),
+    (void*)(&cuImportExternalMemory_init),
+    (void*)(&cuExternalMemoryGetMappedBuffer_init),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_init),
+    (void*)(&cuDestroyExternalMemory_init),
+    (void*)(&cuImportExternalSemaphore_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_init),
+    (void*)(&cuDestroyExternalSemaphore_init),
+    (void*)(&cuStreamWaitValue32_ptsz_init),
+    (void*)(&cuStreamWaitValue64_ptsz_init),
+    (void*)(&cuStreamWriteValue32_ptsz_init),
+    (void*)(&cuStreamWriteValue64_ptsz_init),
+    (void*)(&cuStreamBatchMemOp_ptsz_init),
+    (void*)(&cuFuncGetAttribute_init),
+    (void*)(&cuFuncSetAttribute_init),
+    (void*)(&cuFuncSetCacheConfig_init),
+    (void*)(&cuFuncSetSharedMemConfig_init),
+    (void*)(&cuLaunchKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_init),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_init),
+    (void*)(&cuLaunchHostFunc_ptsz_init),
+    (void*)(&cuFuncSetBlockShape_init),
+    (void*)(&cuFuncSetSharedSize_init),
+    (void*)(&cuParamSetSize_init),
+    (void*)(&cuParamSeti_init),
+    (void*)(&cuParamSetf_init),
+    (void*)(&cuParamSetv_init),
+    (void*)(&cuLaunch_init),
+    (void*)(&cuLaunchGrid_init),
+    (void*)(&cuLaunchGridAsync_init),
+    (void*)(&cuParamSetTexRef_init),
+    (void*)(&cuGraphCreate_init),
+    (void*)(&cuGraphAddKernelNode_init),
+    (void*)(&cuGraphKernelNodeGetParams_init),
+    (void*)(&cuGraphKernelNodeSetParams_init),
+    (void*)(&cuGraphAddMemcpyNode_init),
+    (void*)(&cuGraphMemcpyNodeGetParams_init),
+    (void*)(&cuGraphMemcpyNodeSetParams_init),
+    (void*)(&cuGraphAddMemsetNode_init),
+    (void*)(&cuGraphMemsetNodeGetParams_init),
+    (void*)(&cuGraphMemsetNodeSetParams_init),
+    (void*)(&cuGraphAddHostNode_init),
+    (void*)(&cuGraphHostNodeGetParams_init),
+    (void*)(&cuGraphHostNodeSetParams_init),
+    (void*)(&cuGraphAddChildGraphNode_init),
+    (void*)(&cuGraphChildGraphNodeGetGraph_init),
+    (void*)(&cuGraphAddEmptyNode_init),
+    (void*)(&cuGraphAddEventRecordNode_init),
+    (void*)(&cuGraphEventRecordNodeGetEvent_init),
+    (void*)(&cuGraphEventRecordNodeSetEvent_init),
+    (void*)(&cuGraphAddEventWaitNode_init),
+    (void*)(&cuGraphEventWaitNodeGetEvent_init),
+    (void*)(&cuGraphEventWaitNodeSetEvent_init),
+    (void*)(&cuGraphAddExternalSemaphoresSignalNode_init),
+    (void*)(&cuGraphExternalSemaphoresSignalNodeGetParams_init),
+    (void*)(&cuGraphExternalSemaphoresSignalNodeSetParams_init),
+    (void*)(&cuGraphAddExternalSemaphoresWaitNode_init),
+    (void*)(&cuGraphExternalSemaphoresWaitNodeGetParams_init),
+    (void*)(&cuGraphExternalSemaphoresWaitNodeSetParams_init),
+    (void*)(&cuGraphClone_init),
+    (void*)(&cuGraphNodeFindInClone_init),
+    (void*)(&cuGraphNodeGetType_init),
+    (void*)(&cuGraphGetNodes_init),
+    (void*)(&cuGraphGetRootNodes_init),
+    (void*)(&cuGraphGetEdges_init),
+    (void*)(&cuGraphNodeGetDependencies_init),
+    (void*)(&cuGraphNodeGetDependentNodes_init),
+    (void*)(&cuGraphAddDependencies_init),
+    (void*)(&cuGraphRemoveDependencies_init),
+    (void*)(&cuGraphDestroyNode_init),
+    (void*)(&cuGraphInstantiate_v2_init),
+    (void*)(&cuGraphExecKernelNodeSetParams_init),
+    (void*)(&cuGraphExecMemcpyNodeSetParams_init),
+    (void*)(&cuGraphExecMemsetNodeSetParams_init),
+    (void*)(&cuGraphExecHostNodeSetParams_init),
+    (void*)(&cuGraphExecChildGraphNodeSetParams_init),
+    (void*)(&cuGraphExecEventRecordNodeSetEvent_init),
+    (void*)(&cuGraphExecEventWaitNodeSetEvent_init),
+    (void*)(&cuGraphExecExternalSemaphoresSignalNodeSetParams_init),
+    (void*)(&cuGraphExecExternalSemaphoresWaitNodeSetParams_init),
+    (void*)(&cuGraphUpload_ptsz_init),
+    (void*)(&cuGraphLaunch_ptsz_init),
+    (void*)(&cuGraphExecDestroy_init),
+    (void*)(&cuGraphDestroy_init),
+    (void*)(&cuGraphExecUpdate_init),
+    (void*)(&cuGraphKernelNodeCopyAttributes_init),
+    (void*)(&cuGraphKernelNodeGetAttribute_init),
+    (void*)(&cuGraphKernelNodeSetAttribute_init),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_init),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_init),
+    (void*)(&cuOccupancyMaxPotentialBlockSize_init),
+    (void*)(&cuOccupancyMaxPotentialBlockSizeWithFlags_init),
+    (void*)(&cuOccupancyAvailableDynamicSMemPerBlock_init),
+    (void*)(&cuTexRefSetArray_init),
+    (void*)(&cuTexRefSetMipmappedArray_init),
+    (void*)(&cuTexRefSetAddress_v2_init),
+    (void*)(&cuTexRefSetAddress2D_v3_init),
+    (void*)(&cuTexRefSetFormat_init),
+    (void*)(&cuTexRefSetAddressMode_init),
+    (void*)(&cuTexRefSetFilterMode_init),
+    (void*)(&cuTexRefSetMipmapFilterMode_init),
+    (void*)(&cuTexRefSetMipmapLevelBias_init),
+    (void*)(&cuTexRefSetMipmapLevelClamp_init),
+    (void*)(&cuTexRefSetMaxAnisotropy_init),
+    (void*)(&cuTexRefSetBorderColor_init),
+    (void*)(&cuTexRefSetFlags_init),
+    (void*)(&cuTexRefGetAddress_v2_init),
+    (void*)(&cuTexRefGetArray_init),
+    (void*)(&cuTexRefGetMipmappedArray_init),
+    (void*)(&cuTexRefGetAddressMode_init),
+    (void*)(&cuTexRefGetFilterMode_init),
+    (void*)(&cuTexRefGetFormat_init),
+    (void*)(&cuTexRefGetMipmapFilterMode_init),
+    (void*)(&cuTexRefGetMipmapLevelBias_init),
+    (void*)(&cuTexRefGetMipmapLevelClamp_init),
+    (void*)(&cuTexRefGetMaxAnisotropy_init),
+    (void*)(&cuTexRefGetBorderColor_init),
+    (void*)(&cuTexRefGetFlags_init),
+    (void*)(&cuTexRefCreate_init),
+    (void*)(&cuTexRefDestroy_init),
+    (void*)(&cuSurfRefSetArray_init),
+    (void*)(&cuSurfRefGetArray_init),
+    (void*)(&cuTexObjectCreate_init),
+    (void*)(&cuTexObjectDestroy_init),
+    (void*)(&cuTexObjectGetResourceDesc_init),
+    (void*)(&cuTexObjectGetTextureDesc_init),
+    (void*)(&cuTexObjectGetResourceViewDesc_init),
+    (void*)(&cuSurfObjectCreate_init),
+    (void*)(&cuSurfObjectDestroy_init),
+    (void*)(&cuSurfObjectGetResourceDesc_init),
+    (void*)(&cuDeviceCanAccessPeer_init),
+    (void*)(&cuCtxEnablePeerAccess_init),
+    (void*)(&cuCtxDisablePeerAccess_init),
+    (void*)(&cuDeviceGetP2PAttribute_init),
+    (void*)(&cuGraphicsUnregisterResource_init),
+    (void*)(&cuGraphicsSubResourceGetMappedArray_init),
+    (void*)(&cuGraphicsResourceGetMappedMipmappedArray_init),
+    (void*)(&cuGraphicsResourceGetMappedPointer_v2_init),
+    (void*)(&cuGraphicsResourceSetMapFlags_v2_init),
+    (void*)(&cuGraphicsMapResources_ptsz_init),
+    (void*)(&cuGraphicsUnmapResources_ptsz_init),
+    (void*)(&cuGetExportTable_init),
+    (void*)(&cuFuncGetModule_init),
+    (void*)(&cuMemHostRegister_init),
+    (void*)(&cuGraphicsResourceSetMapFlags_init),
+    (void*)(&cuLinkCreate_init),
+    (void*)(&cuLinkAddData_init),
+    (void*)(&cuLinkAddFile_init),
+    (void*)(&cuTexRefSetAddress2D_v2_init),
+    (void*)(&cuDeviceTotalMem_init),
+    (void*)(&cuCtxCreate_init),
+    (void*)(&cuModuleGetGlobal_init),
+    (void*)(&cuMemGetInfo_init),
+    (void*)(&cuMemAlloc_init),
+    (void*)(&cuMemAllocPitch_init),
+    (void*)(&cuMemFree_init),
+    (void*)(&cuMemGetAddressRange_init),
+    (void*)(&cuMemAllocHost_init),
+    (void*)(&cuMemHostGetDevicePointer_init),
+    (void*)(&cuMemcpyHtoD_init),
+    (void*)(&cuMemcpyDtoH_init),
+    (void*)(&cuMemcpyDtoD_init),
+    (void*)(&cuMemcpyDtoA_init),
+    (void*)(&cuMemcpyAtoD_init),
+    (void*)(&cuMemcpyHtoA_init),
+    (void*)(&cuMemcpyAtoH_init),
+    (void*)(&cuMemcpyAtoA_init),
+    (void*)(&cuMemcpyHtoAAsync_init),
+    (void*)(&cuMemcpyAtoHAsync_init),
+    (void*)(&cuMemcpy2D_init),
+    (void*)(&cuMemcpy2DUnaligned_init),
+    (void*)(&cuMemcpy3D_init),
+    (void*)(&cuMemcpyHtoDAsync_init),
+    (void*)(&cuMemcpyDtoHAsync_init),
+    (void*)(&cuMemcpyDtoDAsync_init),
+    (void*)(&cuMemcpy2DAsync_init),
+    (void*)(&cuMemcpy3DAsync_init),
+    (void*)(&cuMemsetD8_init),
+    (void*)(&cuMemsetD16_init),
+    (void*)(&cuMemsetD32_init),
+    (void*)(&cuMemsetD2D8_init),
+    (void*)(&cuMemsetD2D16_init),
+    (void*)(&cuMemsetD2D32_init),
+    (void*)(&cuArrayCreate_init),
+    (void*)(&cuArrayGetDescriptor_init),
+    (void*)(&cuArray3DCreate_init),
+    (void*)(&cuArray3DGetDescriptor_init),
+    (void*)(&cuTexRefSetAddress_init),
+    (void*)(&cuTexRefSetAddress2D_init),
+    (void*)(&cuTexRefGetAddress_init),
+    (void*)(&cuGraphicsResourceGetMappedPointer_init),
+    (void*)(&cuCtxDestroy_init),
+    (void*)(&cuCtxPopCurrent_init),
+    (void*)(&cuCtxPushCurrent_init),
+    (void*)(&cuStreamDestroy_init),
+    (void*)(&cuEventDestroy_init),
+    (void*)(&cuDevicePrimaryCtxRelease_init),
+    (void*)(&cuDevicePrimaryCtxReset_init),
+    (void*)(&cuDevicePrimaryCtxSetFlags_init),
+    (void*)(&cuMemcpyHtoD_v2_init),
+    (void*)(&cuMemcpyDtoH_v2_init),
+    (void*)(&cuMemcpyDtoD_v2_init),
+    (void*)(&cuMemcpyDtoA_v2_init),
+    (void*)(&cuMemcpyAtoD_v2_init),
+    (void*)(&cuMemcpyHtoA_v2_init),
+    (void*)(&cuMemcpyAtoH_v2_init),
+    (void*)(&cuMemcpyAtoA_v2_init),
+    (void*)(&cuMemcpyHtoAAsync_v2_init),
+    (void*)(&cuMemcpyAtoHAsync_v2_init),
+    (void*)(&cuMemcpy2D_v2_init),
+    (void*)(&cuMemcpy2DUnaligned_v2_init),
+    (void*)(&cuMemcpy3D_v2_init),
+    (void*)(&cuMemcpyHtoDAsync_v2_init),
+    (void*)(&cuMemcpyDtoHAsync_v2_init),
+    (void*)(&cuMemcpyDtoDAsync_v2_init),
+    (void*)(&cuMemcpy2DAsync_v2_init),
+    (void*)(&cuMemcpy3DAsync_v2_init),
+    (void*)(&cuMemsetD8_v2_init),
+    (void*)(&cuMemsetD16_v2_init),
+    (void*)(&cuMemsetD32_v2_init),
+    (void*)(&cuMemsetD2D8_v2_init),
+    (void*)(&cuMemsetD2D16_v2_init),
+    (void*)(&cuMemsetD2D32_v2_init),
+    (void*)(&cuMemcpy_init),
+    (void*)(&cuMemcpyAsync_init),
+    (void*)(&cuMemcpyPeer_init),
+    (void*)(&cuMemcpyPeerAsync_init),
+    (void*)(&cuMemcpy3DPeer_init),
+    (void*)(&cuMemcpy3DPeerAsync_init),
+    (void*)(&cuMemsetD8Async_init),
+    (void*)(&cuMemsetD16Async_init),
+    (void*)(&cuMemsetD32Async_init),
+    (void*)(&cuMemsetD2D8Async_init),
+    (void*)(&cuMemsetD2D16Async_init),
+    (void*)(&cuMemsetD2D32Async_init),
+    (void*)(&cuStreamGetPriority_init),
+    (void*)(&cuStreamGetFlags_init),
+    (void*)(&cuStreamGetCtx_init),
+    (void*)(&cuStreamWaitEvent_init),
+    (void*)(&cuStreamAddCallback_init),
+    (void*)(&cuStreamAttachMemAsync_init),
+    (void*)(&cuStreamQuery_init),
+    (void*)(&cuStreamSynchronize_init),
+    (void*)(&cuEventRecord_init),
+    (void*)(&cuEventRecordWithFlags_init),
+    (void*)(&cuLaunchKernel_init),
+    (void*)(&cuLaunchHostFunc_init),
+    (void*)(&cuGraphicsMapResources_init),
+    (void*)(&cuGraphicsUnmapResources_init),
+    (void*)(&cuStreamWriteValue32_init),
+    (void*)(&cuStreamWaitValue32_init),
+    (void*)(&cuStreamWriteValue64_init),
+    (void*)(&cuStreamWaitValue64_init),
+    (void*)(&cuStreamBatchMemOp_init),
+    (void*)(&cuMemPrefetchAsync_init),
+    (void*)(&cuLaunchCooperativeKernel_init),
+    (void*)(&cuSignalExternalSemaphoresAsync_init),
+    (void*)(&cuWaitExternalSemaphoresAsync_init),
+    (void*)(&cuStreamBeginCapture_init),
+    (void*)(&cuStreamBeginCapture_ptsz_init),
+    (void*)(&cuStreamBeginCapture_v2_init),
+    (void*)(&cuStreamEndCapture_init),
+    (void*)(&cuStreamIsCapturing_init),
+    (void*)(&cuStreamGetCaptureInfo_init),
+    (void*)(&cuGraphUpload_init),
+    (void*)(&cuGraphLaunch_init),
+    (void*)(&cuStreamCopyAttributes_init),
+    (void*)(&cuStreamGetAttribute_init),
+    (void*)(&cuStreamSetAttribute_init),
+    (void*)(&cuIpcOpenMemHandle_init),
+    (void*)(&cuGraphInstantiate_init),
+    (void*)(&cuMemMapArrayAsync_init),
+    (void*)(&cuMemFreeAsync_init),
+    (void*)(&cuMemAllocAsync_init),
+    (void*)(&cuMemAllocFromPoolAsync_init),
+    (void*)(&cuProfilerInitialize_init),
+    (void*)(&cuProfilerStart_init),
+    (void*)(&cuProfilerStop_init)};
+static void* g_func_table_error[NR_FUNC] = {(void*)(&cuGetErrorString_error),
+    (void*)(&cuGetErrorName_error),
+    (void*)(&cuInit_error),
+    (void*)(&cuDriverGetVersion_error),
+    (void*)(&cuDeviceGet_error),
+    (void*)(&cuDeviceGetCount_error),
+    (void*)(&cuDeviceGetName_error),
+    (void*)(&cuDeviceGetUuid_error),
+    (void*)(&cuDeviceGetLuid_error),
+    (void*)(&cuDeviceTotalMem_v2_error),
+    (void*)(&cuDeviceGetTexture1DLinearMaxWidth_error),
+    (void*)(&cuDeviceGetAttribute_error),
+    (void*)(&cuDeviceGetNvSciSyncAttributes_error),
+    (void*)(&cuDeviceSetMemPool_error),
+    (void*)(&cuDeviceGetMemPool_error),
+    (void*)(&cuDeviceGetDefaultMemPool_error),
+    (void*)(&cuDeviceGetProperties_error),
+    (void*)(&cuDeviceComputeCapability_error),
+    (void*)(&cuDevicePrimaryCtxRetain_error),
+    (void*)(&cuDevicePrimaryCtxRelease_v2_error),
+    (void*)(&cuDevicePrimaryCtxSetFlags_v2_error),
+    (void*)(&cuDevicePrimaryCtxGetState_error),
+    (void*)(&cuDevicePrimaryCtxReset_v2_error),
+    (void*)(&cuCtxCreate_v2_error),
+    (void*)(&cuCtxDestroy_v2_error),
+    (void*)(&cuCtxPushCurrent_v2_error),
+    (void*)(&cuCtxPopCurrent_v2_error),
+    (void*)(&cuCtxSetCurrent_error),
+    (void*)(&cuCtxGetCurrent_error),
+    (void*)(&cuCtxGetDevice_error),
+    (void*)(&cuCtxGetFlags_error),
+    (void*)(&cuCtxSynchronize_error),
+    (void*)(&cuCtxSetLimit_error),
+    (void*)(&cuCtxGetLimit_error),
+    (void*)(&cuCtxGetCacheConfig_error),
+    (void*)(&cuCtxSetCacheConfig_error),
+    (void*)(&cuCtxGetSharedMemConfig_error),
+    (void*)(&cuCtxSetSharedMemConfig_error),
+    (void*)(&cuCtxGetApiVersion_error),
+    (void*)(&cuCtxGetStreamPriorityRange_error),
+    (void*)(&cuCtxResetPersistingL2Cache_error),
+    (void*)(&cuCtxAttach_error),
+    (void*)(&cuCtxDetach_error),
+    (void*)(&cuModuleLoad_error),
+    (void*)(&cuModuleLoadData_error),
+    (void*)(&cuModuleLoadDataEx_error),
+    (void*)(&cuModuleLoadFatBinary_error),
+    (void*)(&cuModuleUnload_error),
+    (void*)(&cuModuleGetFunction_error),
+    (void*)(&cuModuleGetGlobal_v2_error),
+    (void*)(&cuModuleGetTexRef_error),
+    (void*)(&cuModuleGetSurfRef_error),
+    (void*)(&cuLinkCreate_v2_error),
+    (void*)(&cuLinkAddData_v2_error),
+    (void*)(&cuLinkAddFile_v2_error),
+    (void*)(&cuLinkComplete_error),
+    (void*)(&cuLinkDestroy_error),
+    (void*)(&cuMemGetInfo_v2_error),
+    (void*)(&cuMemAlloc_v2_error),
+    (void*)(&cuMemAllocPitch_v2_error),
+    (void*)(&cuMemFree_v2_error),
+    (void*)(&cuMemGetAddressRange_v2_error),
+    (void*)(&cuMemAllocHost_v2_error),
+    (void*)(&cuMemFreeHost_error),
+    (void*)(&cuMemHostAlloc_error),
+    (void*)(&cuMemHostGetDevicePointer_v2_error),
+    (void*)(&cuMemHostGetFlags_error),
+    (void*)(&cuMemAllocManaged_error),
+    (void*)(&cuDeviceGetByPCIBusId_error),
+    (void*)(&cuDeviceGetPCIBusId_error),
+    (void*)(&cuIpcGetEventHandle_error),
+    (void*)(&cuIpcOpenEventHandle_error),
+    (void*)(&cuIpcGetMemHandle_error),
+    (void*)(&cuIpcOpenMemHandle_v2_error),
+    (void*)(&cuIpcCloseMemHandle_error),
+    (void*)(&cuMemHostRegister_v2_error),
+    (void*)(&cuMemHostUnregister_error),
+    (void*)(&cuMemcpy_ptds_error),
+    (void*)(&cuMemcpyPeer_ptds_error),
+    (void*)(&cuMemcpyHtoD_v2_ptds_error),
+    (void*)(&cuMemcpyDtoH_v2_ptds_error),
+    (void*)(&cuMemcpyDtoD_v2_ptds_error),
+    (void*)(&cuMemcpyDtoA_v2_ptds_error),
+    (void*)(&cuMemcpyAtoD_v2_ptds_error),
+    (void*)(&cuMemcpyHtoA_v2_ptds_error),
+    (void*)(&cuMemcpyAtoH_v2_ptds_error),
+    (void*)(&cuMemcpyAtoA_v2_ptds_error),
+    (void*)(&cuMemcpy2D_v2_ptds_error),
+    (void*)(&cuMemcpy2DUnaligned_v2_ptds_error),
+    (void*)(&cuMemcpy3D_v2_ptds_error),
+    (void*)(&cuMemcpy3DPeer_ptds_error),
+    (void*)(&cuMemcpyAsync_ptsz_error),
+    (void*)(&cuMemcpyPeerAsync_ptsz_error),
+    (void*)(&cuMemcpyHtoDAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyDtoHAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyDtoDAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyHtoAAsync_v2_ptsz_error),
+    (void*)(&cuMemcpyAtoHAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy2DAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy3DAsync_v2_ptsz_error),
+    (void*)(&cuMemcpy3DPeerAsync_ptsz_error),
+    (void*)(&cuMemsetD8_v2_ptds_error),
+    (void*)(&cuMemsetD16_v2_ptds_error),
+    (void*)(&cuMemsetD32_v2_ptds_error),
+    (void*)(&cuMemsetD2D8_v2_ptds_error),
+    (void*)(&cuMemsetD2D16_v2_ptds_error),
+    (void*)(&cuMemsetD2D32_v2_ptds_error),
+    (void*)(&cuMemsetD8Async_ptsz_error),
+    (void*)(&cuMemsetD16Async_ptsz_error),
+    (void*)(&cuMemsetD32Async_ptsz_error),
+    (void*)(&cuMemsetD2D8Async_ptsz_error),
+    (void*)(&cuMemsetD2D16Async_ptsz_error),
+    (void*)(&cuMemsetD2D32Async_ptsz_error),
+    (void*)(&cuArrayCreate_v2_error),
+    (void*)(&cuArrayGetDescriptor_v2_error),
+    (void*)(&cuArrayGetSparseProperties_error),
+    (void*)(&cuMipmappedArrayGetSparseProperties_error),
+    (void*)(&cuArrayGetPlane_error),
+    (void*)(&cuArrayDestroy_error),
+    (void*)(&cuArray3DCreate_v2_error),
+    (void*)(&cuArray3DGetDescriptor_v2_error),
+    (void*)(&cuMipmappedArrayCreate_error),
+    (void*)(&cuMipmappedArrayGetLevel_error),
+    (void*)(&cuMipmappedArrayDestroy_error),
+    (void*)(&cuMemAddressReserve_error),
+    (void*)(&cuMemAddressFree_error),
+    (void*)(&cuMemCreate_error),
+    (void*)(&cuMemRelease_error),
+    (void*)(&cuMemMap_error),
+    (void*)(&cuMemMapArrayAsync_ptsz_error),
+    (void*)(&cuMemUnmap_error),
+    (void*)(&cuMemSetAccess_error),
+    (void*)(&cuMemGetAccess_error),
+    (void*)(&cuMemExportToShareableHandle_error),
+    (void*)(&cuMemImportFromShareableHandle_error),
+    (void*)(&cuMemGetAllocationGranularity_error),
+    (void*)(&cuMemGetAllocationPropertiesFromHandle_error),
+    (void*)(&cuMemRetainAllocationHandle_error),
+    (void*)(&cuMemFreeAsync_ptsz_error),
+    (void*)(&cuMemAllocAsync_ptsz_error),
+    (void*)(&cuMemPoolTrimTo_error),
+    (void*)(&cuMemPoolSetAttribute_error),
+    (void*)(&cuMemPoolGetAttribute_error),
+    (void*)(&cuMemPoolSetAccess_error),
+    (void*)(&cuMemPoolGetAccess_error),
+    (void*)(&cuMemPoolCreate_error),
+    (void*)(&cuMemPoolDestroy_error),
+    (void*)(&cuMemAllocFromPoolAsync_ptsz_error),
+    (void*)(&cuMemPoolExportToShareableHandle_error),
+    (void*)(&cuMemPoolImportFromShareableHandle_error),
+    (void*)(&cuMemPoolExportPointer_error),
+    (void*)(&cuMemPoolImportPointer_error),
+    (void*)(&cuPointerGetAttribute_error),
+    (void*)(&cuMemPrefetchAsync_ptsz_error),
+    (void*)(&cuMemAdvise_error),
+    (void*)(&cuMemRangeGetAttribute_error),
+    (void*)(&cuMemRangeGetAttributes_error),
+    (void*)(&cuPointerSetAttribute_error),
+    (void*)(&cuPointerGetAttributes_error),
+    (void*)(&cuStreamCreate_error),
+    (void*)(&cuStreamCreateWithPriority_error),
+    (void*)(&cuStreamGetPriority_ptsz_error),
+    (void*)(&cuStreamGetFlags_ptsz_error),
+    (void*)(&cuStreamGetCtx_ptsz_error),
+    (void*)(&cuStreamWaitEvent_ptsz_error),
+    (void*)(&cuStreamAddCallback_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_ptsz_error),
+    (void*)(&cuThreadExchangeStreamCaptureMode_error),
+    (void*)(&cuStreamEndCapture_ptsz_error),
+    (void*)(&cuStreamIsCapturing_ptsz_error),
+    (void*)(&cuStreamGetCaptureInfo_ptsz_error),
+    (void*)(&cuStreamAttachMemAsync_ptsz_error),
+    (void*)(&cuStreamQuery_ptsz_error),
+    (void*)(&cuStreamSynchronize_ptsz_error),
+    (void*)(&cuStreamDestroy_v2_error),
+    (void*)(&cuStreamCopyAttributes_ptsz_error),
+    (void*)(&cuStreamGetAttribute_ptsz_error),
+    (void*)(&cuStreamSetAttribute_ptsz_error),
+    (void*)(&cuEventCreate_error),
+    (void*)(&cuEventRecord_ptsz_error),
+    (void*)(&cuEventRecordWithFlags_ptsz_error),
+    (void*)(&cuEventQuery_error),
+    (void*)(&cuEventSynchronize_error),
+    (void*)(&cuEventDestroy_v2_error),
+    (void*)(&cuEventElapsedTime_error),
+    (void*)(&cuImportExternalMemory_error),
+    (void*)(&cuExternalMemoryGetMappedBuffer_error),
+    (void*)(&cuExternalMemoryGetMappedMipmappedArray_error),
+    (void*)(&cuDestroyExternalMemory_error),
+    (void*)(&cuImportExternalSemaphore_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_ptsz_error),
+    (void*)(&cuDestroyExternalSemaphore_error),
+    (void*)(&cuStreamWaitValue32_ptsz_error),
+    (void*)(&cuStreamWaitValue64_ptsz_error),
+    (void*)(&cuStreamWriteValue32_ptsz_error),
+    (void*)(&cuStreamWriteValue64_ptsz_error),
+    (void*)(&cuStreamBatchMemOp_ptsz_error),
+    (void*)(&cuFuncGetAttribute_error),
+    (void*)(&cuFuncSetAttribute_error),
+    (void*)(&cuFuncSetCacheConfig_error),
+    (void*)(&cuFuncSetSharedMemConfig_error),
+    (void*)(&cuLaunchKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernel_ptsz_error),
+    (void*)(&cuLaunchCooperativeKernelMultiDevice_error),
+    (void*)(&cuLaunchHostFunc_ptsz_error),
+    (void*)(&cuFuncSetBlockShape_error),
+    (void*)(&cuFuncSetSharedSize_error),
+    (void*)(&cuParamSetSize_error),
+    (void*)(&cuParamSeti_error),
+    (void*)(&cuParamSetf_error),
+    (void*)(&cuParamSetv_error),
+    (void*)(&cuLaunch_error),
+    (void*)(&cuLaunchGrid_error),
+    (void*)(&cuLaunchGridAsync_error),
+    (void*)(&cuParamSetTexRef_error),
+    (void*)(&cuGraphCreate_error),
+    (void*)(&cuGraphAddKernelNode_error),
+    (void*)(&cuGraphKernelNodeGetParams_error),
+    (void*)(&cuGraphKernelNodeSetParams_error),
+    (void*)(&cuGraphAddMemcpyNode_error),
+    (void*)(&cuGraphMemcpyNodeGetParams_error),
+    (void*)(&cuGraphMemcpyNodeSetParams_error),
+    (void*)(&cuGraphAddMemsetNode_error),
+    (void*)(&cuGraphMemsetNodeGetParams_error),
+    (void*)(&cuGraphMemsetNodeSetParams_error),
+    (void*)(&cuGraphAddHostNode_error),
+    (void*)(&cuGraphHostNodeGetParams_error),
+    (void*)(&cuGraphHostNodeSetParams_error),
+    (void*)(&cuGraphAddChildGraphNode_error),
+    (void*)(&cuGraphChildGraphNodeGetGraph_error),
+    (void*)(&cuGraphAddEmptyNode_error),
+    (void*)(&cuGraphAddEventRecordNode_error),
+    (void*)(&cuGraphEventRecordNodeGetEvent_error),
+    (void*)(&cuGraphEventRecordNodeSetEvent_error),
+    (void*)(&cuGraphAddEventWaitNode_error),
+    (void*)(&cuGraphEventWaitNodeGetEvent_error),
+    (void*)(&cuGraphEventWaitNodeSetEvent_error),
+    (void*)(&cuGraphAddExternalSemaphoresSignalNode_error),
+    (void*)(&cuGraphExternalSemaphoresSignalNodeGetParams_error),
+    (void*)(&cuGraphExternalSemaphoresSignalNodeSetParams_error),
+    (void*)(&cuGraphAddExternalSemaphoresWaitNode_error),
+    (void*)(&cuGraphExternalSemaphoresWaitNodeGetParams_error),
+    (void*)(&cuGraphExternalSemaphoresWaitNodeSetParams_error),
+    (void*)(&cuGraphClone_error),
+    (void*)(&cuGraphNodeFindInClone_error),
+    (void*)(&cuGraphNodeGetType_error),
+    (void*)(&cuGraphGetNodes_error),
+    (void*)(&cuGraphGetRootNodes_error),
+    (void*)(&cuGraphGetEdges_error),
+    (void*)(&cuGraphNodeGetDependencies_error),
+    (void*)(&cuGraphNodeGetDependentNodes_error),
+    (void*)(&cuGraphAddDependencies_error),
+    (void*)(&cuGraphRemoveDependencies_error),
+    (void*)(&cuGraphDestroyNode_error),
+    (void*)(&cuGraphInstantiate_v2_error),
+    (void*)(&cuGraphExecKernelNodeSetParams_error),
+    (void*)(&cuGraphExecMemcpyNodeSetParams_error),
+    (void*)(&cuGraphExecMemsetNodeSetParams_error),
+    (void*)(&cuGraphExecHostNodeSetParams_error),
+    (void*)(&cuGraphExecChildGraphNodeSetParams_error),
+    (void*)(&cuGraphExecEventRecordNodeSetEvent_error),
+    (void*)(&cuGraphExecEventWaitNodeSetEvent_error),
+    (void*)(&cuGraphExecExternalSemaphoresSignalNodeSetParams_error),
+    (void*)(&cuGraphExecExternalSemaphoresWaitNodeSetParams_error),
+    (void*)(&cuGraphUpload_ptsz_error),
+    (void*)(&cuGraphLaunch_ptsz_error),
+    (void*)(&cuGraphExecDestroy_error),
+    (void*)(&cuGraphDestroy_error),
+    (void*)(&cuGraphExecUpdate_error),
+    (void*)(&cuGraphKernelNodeCopyAttributes_error),
+    (void*)(&cuGraphKernelNodeGetAttribute_error),
+    (void*)(&cuGraphKernelNodeSetAttribute_error),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessor_error),
+    (void*)(&cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_error),
+    (void*)(&cuOccupancyMaxPotentialBlockSize_error),
+    (void*)(&cuOccupancyMaxPotentialBlockSizeWithFlags_error),
+    (void*)(&cuOccupancyAvailableDynamicSMemPerBlock_error),
+    (void*)(&cuTexRefSetArray_error),
+    (void*)(&cuTexRefSetMipmappedArray_error),
+    (void*)(&cuTexRefSetAddress_v2_error),
+    (void*)(&cuTexRefSetAddress2D_v3_error),
+    (void*)(&cuTexRefSetFormat_error),
+    (void*)(&cuTexRefSetAddressMode_error),
+    (void*)(&cuTexRefSetFilterMode_error),
+    (void*)(&cuTexRefSetMipmapFilterMode_error),
+    (void*)(&cuTexRefSetMipmapLevelBias_error),
+    (void*)(&cuTexRefSetMipmapLevelClamp_error),
+    (void*)(&cuTexRefSetMaxAnisotropy_error),
+    (void*)(&cuTexRefSetBorderColor_error),
+    (void*)(&cuTexRefSetFlags_error),
+    (void*)(&cuTexRefGetAddress_v2_error),
+    (void*)(&cuTexRefGetArray_error),
+    (void*)(&cuTexRefGetMipmappedArray_error),
+    (void*)(&cuTexRefGetAddressMode_error),
+    (void*)(&cuTexRefGetFilterMode_error),
+    (void*)(&cuTexRefGetFormat_error),
+    (void*)(&cuTexRefGetMipmapFilterMode_error),
+    (void*)(&cuTexRefGetMipmapLevelBias_error),
+    (void*)(&cuTexRefGetMipmapLevelClamp_error),
+    (void*)(&cuTexRefGetMaxAnisotropy_error),
+    (void*)(&cuTexRefGetBorderColor_error),
+    (void*)(&cuTexRefGetFlags_error),
+    (void*)(&cuTexRefCreate_error),
+    (void*)(&cuTexRefDestroy_error),
+    (void*)(&cuSurfRefSetArray_error),
+    (void*)(&cuSurfRefGetArray_error),
+    (void*)(&cuTexObjectCreate_error),
+    (void*)(&cuTexObjectDestroy_error),
+    (void*)(&cuTexObjectGetResourceDesc_error),
+    (void*)(&cuTexObjectGetTextureDesc_error),
+    (void*)(&cuTexObjectGetResourceViewDesc_error),
+    (void*)(&cuSurfObjectCreate_error),
+    (void*)(&cuSurfObjectDestroy_error),
+    (void*)(&cuSurfObjectGetResourceDesc_error),
+    (void*)(&cuDeviceCanAccessPeer_error),
+    (void*)(&cuCtxEnablePeerAccess_error),
+    (void*)(&cuCtxDisablePeerAccess_error),
+    (void*)(&cuDeviceGetP2PAttribute_error),
+    (void*)(&cuGraphicsUnregisterResource_error),
+    (void*)(&cuGraphicsSubResourceGetMappedArray_error),
+    (void*)(&cuGraphicsResourceGetMappedMipmappedArray_error),
+    (void*)(&cuGraphicsResourceGetMappedPointer_v2_error),
+    (void*)(&cuGraphicsResourceSetMapFlags_v2_error),
+    (void*)(&cuGraphicsMapResources_ptsz_error),
+    (void*)(&cuGraphicsUnmapResources_ptsz_error),
+    (void*)(&cuGetExportTable_error),
+    (void*)(&cuFuncGetModule_error),
+    (void*)(&cuMemHostRegister_error),
+    (void*)(&cuGraphicsResourceSetMapFlags_error),
+    (void*)(&cuLinkCreate_error),
+    (void*)(&cuLinkAddData_error),
+    (void*)(&cuLinkAddFile_error),
+    (void*)(&cuTexRefSetAddress2D_v2_error),
+    (void*)(&cuDeviceTotalMem_error),
+    (void*)(&cuCtxCreate_error),
+    (void*)(&cuModuleGetGlobal_error),
+    (void*)(&cuMemGetInfo_error),
+    (void*)(&cuMemAlloc_error),
+    (void*)(&cuMemAllocPitch_error),
+    (void*)(&cuMemFree_error),
+    (void*)(&cuMemGetAddressRange_error),
+    (void*)(&cuMemAllocHost_error),
+    (void*)(&cuMemHostGetDevicePointer_error),
+    (void*)(&cuMemcpyHtoD_error),
+    (void*)(&cuMemcpyDtoH_error),
+    (void*)(&cuMemcpyDtoD_error),
+    (void*)(&cuMemcpyDtoA_error),
+    (void*)(&cuMemcpyAtoD_error),
+    (void*)(&cuMemcpyHtoA_error),
+    (void*)(&cuMemcpyAtoH_error),
+    (void*)(&cuMemcpyAtoA_error),
+    (void*)(&cuMemcpyHtoAAsync_error),
+    (void*)(&cuMemcpyAtoHAsync_error),
+    (void*)(&cuMemcpy2D_error),
+    (void*)(&cuMemcpy2DUnaligned_error),
+    (void*)(&cuMemcpy3D_error),
+    (void*)(&cuMemcpyHtoDAsync_error),
+    (void*)(&cuMemcpyDtoHAsync_error),
+    (void*)(&cuMemcpyDtoDAsync_error),
+    (void*)(&cuMemcpy2DAsync_error),
+    (void*)(&cuMemcpy3DAsync_error),
+    (void*)(&cuMemsetD8_error),
+    (void*)(&cuMemsetD16_error),
+    (void*)(&cuMemsetD32_error),
+    (void*)(&cuMemsetD2D8_error),
+    (void*)(&cuMemsetD2D16_error),
+    (void*)(&cuMemsetD2D32_error),
+    (void*)(&cuArrayCreate_error),
+    (void*)(&cuArrayGetDescriptor_error),
+    (void*)(&cuArray3DCreate_error),
+    (void*)(&cuArray3DGetDescriptor_error),
+    (void*)(&cuTexRefSetAddress_error),
+    (void*)(&cuTexRefSetAddress2D_error),
+    (void*)(&cuTexRefGetAddress_error),
+    (void*)(&cuGraphicsResourceGetMappedPointer_error),
+    (void*)(&cuCtxDestroy_error),
+    (void*)(&cuCtxPopCurrent_error),
+    (void*)(&cuCtxPushCurrent_error),
+    (void*)(&cuStreamDestroy_error),
+    (void*)(&cuEventDestroy_error),
+    (void*)(&cuDevicePrimaryCtxRelease_error),
+    (void*)(&cuDevicePrimaryCtxReset_error),
+    (void*)(&cuDevicePrimaryCtxSetFlags_error),
+    (void*)(&cuMemcpyHtoD_v2_error),
+    (void*)(&cuMemcpyDtoH_v2_error),
+    (void*)(&cuMemcpyDtoD_v2_error),
+    (void*)(&cuMemcpyDtoA_v2_error),
+    (void*)(&cuMemcpyAtoD_v2_error),
+    (void*)(&cuMemcpyHtoA_v2_error),
+    (void*)(&cuMemcpyAtoH_v2_error),
+    (void*)(&cuMemcpyAtoA_v2_error),
+    (void*)(&cuMemcpyHtoAAsync_v2_error),
+    (void*)(&cuMemcpyAtoHAsync_v2_error),
+    (void*)(&cuMemcpy2D_v2_error),
+    (void*)(&cuMemcpy2DUnaligned_v2_error),
+    (void*)(&cuMemcpy3D_v2_error),
+    (void*)(&cuMemcpyHtoDAsync_v2_error),
+    (void*)(&cuMemcpyDtoHAsync_v2_error),
+    (void*)(&cuMemcpyDtoDAsync_v2_error),
+    (void*)(&cuMemcpy2DAsync_v2_error),
+    (void*)(&cuMemcpy3DAsync_v2_error),
+    (void*)(&cuMemsetD8_v2_error),
+    (void*)(&cuMemsetD16_v2_error),
+    (void*)(&cuMemsetD32_v2_error),
+    (void*)(&cuMemsetD2D8_v2_error),
+    (void*)(&cuMemsetD2D16_v2_error),
+    (void*)(&cuMemsetD2D32_v2_error),
+    (void*)(&cuMemcpy_error),
+    (void*)(&cuMemcpyAsync_error),
+    (void*)(&cuMemcpyPeer_error),
+    (void*)(&cuMemcpyPeerAsync_error),
+    (void*)(&cuMemcpy3DPeer_error),
+    (void*)(&cuMemcpy3DPeerAsync_error),
+    (void*)(&cuMemsetD8Async_error),
+    (void*)(&cuMemsetD16Async_error),
+    (void*)(&cuMemsetD32Async_error),
+    (void*)(&cuMemsetD2D8Async_error),
+    (void*)(&cuMemsetD2D16Async_error),
+    (void*)(&cuMemsetD2D32Async_error),
+    (void*)(&cuStreamGetPriority_error),
+    (void*)(&cuStreamGetFlags_error),
+    (void*)(&cuStreamGetCtx_error),
+    (void*)(&cuStreamWaitEvent_error),
+    (void*)(&cuStreamAddCallback_error),
+    (void*)(&cuStreamAttachMemAsync_error),
+    (void*)(&cuStreamQuery_error),
+    (void*)(&cuStreamSynchronize_error),
+    (void*)(&cuEventRecord_error),
+    (void*)(&cuEventRecordWithFlags_error),
+    (void*)(&cuLaunchKernel_error),
+    (void*)(&cuLaunchHostFunc_error),
+    (void*)(&cuGraphicsMapResources_error),
+    (void*)(&cuGraphicsUnmapResources_error),
+    (void*)(&cuStreamWriteValue32_error),
+    (void*)(&cuStreamWaitValue32_error),
+    (void*)(&cuStreamWriteValue64_error),
+    (void*)(&cuStreamWaitValue64_error),
+    (void*)(&cuStreamBatchMemOp_error),
+    (void*)(&cuMemPrefetchAsync_error),
+    (void*)(&cuLaunchCooperativeKernel_error),
+    (void*)(&cuSignalExternalSemaphoresAsync_error),
+    (void*)(&cuWaitExternalSemaphoresAsync_error),
+    (void*)(&cuStreamBeginCapture_error),
+    (void*)(&cuStreamBeginCapture_ptsz_error),
+    (void*)(&cuStreamBeginCapture_v2_error),
+    (void*)(&cuStreamEndCapture_error),
+    (void*)(&cuStreamIsCapturing_error),
+    (void*)(&cuStreamGetCaptureInfo_error),
+    (void*)(&cuGraphUpload_error),
+    (void*)(&cuGraphLaunch_error),
+    (void*)(&cuStreamCopyAttributes_error),
+    (void*)(&cuStreamGetAttribute_error),
+    (void*)(&cuStreamSetAttribute_error),
+    (void*)(&cuIpcOpenMemHandle_error),
+    (void*)(&cuGraphInstantiate_error),
+    (void*)(&cuMemMapArrayAsync_error),
+    (void*)(&cuMemFreeAsync_error),
+    (void*)(&cuMemAllocAsync_error),
+    (void*)(&cuMemAllocFromPoolAsync_error),
+    (void*)(&cuProfilerInitialize_error),
+    (void*)(&cuProfilerStart_error),
+    (void*)(&cuProfilerStop_error)};
+static const char* const g_func_name[NR_FUNC] = {"cuGetErrorString",
+    "cuGetErrorName",
+    "cuInit",
+    "cuDriverGetVersion",
+    "cuDeviceGet",
+    "cuDeviceGetCount",
+    "cuDeviceGetName",
+    "cuDeviceGetUuid",
+    "cuDeviceGetLuid",
+    "cuDeviceTotalMem_v2",
+    "cuDeviceGetTexture1DLinearMaxWidth",
+    "cuDeviceGetAttribute",
+    "cuDeviceGetNvSciSyncAttributes",
+    "cuDeviceSetMemPool",
+    "cuDeviceGetMemPool",
+    "cuDeviceGetDefaultMemPool",
+    "cuDeviceGetProperties",
+    "cuDeviceComputeCapability",
+    "cuDevicePrimaryCtxRetain",
+    "cuDevicePrimaryCtxRelease_v2",
+    "cuDevicePrimaryCtxSetFlags_v2",
+    "cuDevicePrimaryCtxGetState",
+    "cuDevicePrimaryCtxReset_v2",
+    "cuCtxCreate_v2",
+    "cuCtxDestroy_v2",
+    "cuCtxPushCurrent_v2",
+    "cuCtxPopCurrent_v2",
+    "cuCtxSetCurrent",
+    "cuCtxGetCurrent",
+    "cuCtxGetDevice",
+    "cuCtxGetFlags",
+    "cuCtxSynchronize",
+    "cuCtxSetLimit",
+    "cuCtxGetLimit",
+    "cuCtxGetCacheConfig",
+    "cuCtxSetCacheConfig",
+    "cuCtxGetSharedMemConfig",
+    "cuCtxSetSharedMemConfig",
+    "cuCtxGetApiVersion",
+    "cuCtxGetStreamPriorityRange",
+    "cuCtxResetPersistingL2Cache",
+    "cuCtxAttach",
+    "cuCtxDetach",
+    "cuModuleLoad",
+    "cuModuleLoadData",
+    "cuModuleLoadDataEx",
+    "cuModuleLoadFatBinary",
+    "cuModuleUnload",
+    "cuModuleGetFunction",
+    "cuModuleGetGlobal_v2",
+    "cuModuleGetTexRef",
+    "cuModuleGetSurfRef",
+    "cuLinkCreate_v2",
+    "cuLinkAddData_v2",
+    "cuLinkAddFile_v2",
+    "cuLinkComplete",
+    "cuLinkDestroy",
+    "cuMemGetInfo_v2",
+    "cuMemAlloc_v2",
+    "cuMemAllocPitch_v2",
+    "cuMemFree_v2",
+    "cuMemGetAddressRange_v2",
+    "cuMemAllocHost_v2",
+    "cuMemFreeHost",
+    "cuMemHostAlloc",
+    "cuMemHostGetDevicePointer_v2",
+    "cuMemHostGetFlags",
+    "cuMemAllocManaged",
+    "cuDeviceGetByPCIBusId",
+    "cuDeviceGetPCIBusId",
+    "cuIpcGetEventHandle",
+    "cuIpcOpenEventHandle",
+    "cuIpcGetMemHandle",
+    "cuIpcOpenMemHandle_v2",
+    "cuIpcCloseMemHandle",
+    "cuMemHostRegister_v2",
+    "cuMemHostUnregister",
+    "cuMemcpy_ptds",
+    "cuMemcpyPeer_ptds",
+    "cuMemcpyHtoD_v2_ptds",
+    "cuMemcpyDtoH_v2_ptds",
+    "cuMemcpyDtoD_v2_ptds",
+    "cuMemcpyDtoA_v2_ptds",
+    "cuMemcpyAtoD_v2_ptds",
+    "cuMemcpyHtoA_v2_ptds",
+    "cuMemcpyAtoH_v2_ptds",
+    "cuMemcpyAtoA_v2_ptds",
+    "cuMemcpy2D_v2_ptds",
+    "cuMemcpy2DUnaligned_v2_ptds",
+    "cuMemcpy3D_v2_ptds",
+    "cuMemcpy3DPeer_ptds",
+    "cuMemcpyAsync_ptsz",
+    "cuMemcpyPeerAsync_ptsz",
+    "cuMemcpyHtoDAsync_v2_ptsz",
+    "cuMemcpyDtoHAsync_v2_ptsz",
+    "cuMemcpyDtoDAsync_v2_ptsz",
+    "cuMemcpyHtoAAsync_v2_ptsz",
+    "cuMemcpyAtoHAsync_v2_ptsz",
+    "cuMemcpy2DAsync_v2_ptsz",
+    "cuMemcpy3DAsync_v2_ptsz",
+    "cuMemcpy3DPeerAsync_ptsz",
+    "cuMemsetD8_v2_ptds",
+    "cuMemsetD16_v2_ptds",
+    "cuMemsetD32_v2_ptds",
+    "cuMemsetD2D8_v2_ptds",
+    "cuMemsetD2D16_v2_ptds",
+    "cuMemsetD2D32_v2_ptds",
+    "cuMemsetD8Async_ptsz",
+    "cuMemsetD16Async_ptsz",
+    "cuMemsetD32Async_ptsz",
+    "cuMemsetD2D8Async_ptsz",
+    "cuMemsetD2D16Async_ptsz",
+    "cuMemsetD2D32Async_ptsz",
+    "cuArrayCreate_v2",
+    "cuArrayGetDescriptor_v2",
+    "cuArrayGetSparseProperties",
+    "cuMipmappedArrayGetSparseProperties",
+    "cuArrayGetPlane",
+    "cuArrayDestroy",
+    "cuArray3DCreate_v2",
+    "cuArray3DGetDescriptor_v2",
+    "cuMipmappedArrayCreate",
+    "cuMipmappedArrayGetLevel",
+    "cuMipmappedArrayDestroy",
+    "cuMemAddressReserve",
+    "cuMemAddressFree",
+    "cuMemCreate",
+    "cuMemRelease",
+    "cuMemMap",
+    "cuMemMapArrayAsync_ptsz",
+    "cuMemUnmap",
+    "cuMemSetAccess",
+    "cuMemGetAccess",
+    "cuMemExportToShareableHandle",
+    "cuMemImportFromShareableHandle",
+    "cuMemGetAllocationGranularity",
+    "cuMemGetAllocationPropertiesFromHandle",
+    "cuMemRetainAllocationHandle",
+    "cuMemFreeAsync_ptsz",
+    "cuMemAllocAsync_ptsz",
+    "cuMemPoolTrimTo",
+    "cuMemPoolSetAttribute",
+    "cuMemPoolGetAttribute",
+    "cuMemPoolSetAccess",
+    "cuMemPoolGetAccess",
+    "cuMemPoolCreate",
+    "cuMemPoolDestroy",
+    "cuMemAllocFromPoolAsync_ptsz",
+    "cuMemPoolExportToShareableHandle",
+    "cuMemPoolImportFromShareableHandle",
+    "cuMemPoolExportPointer",
+    "cuMemPoolImportPointer",
+    "cuPointerGetAttribute",
+    "cuMemPrefetchAsync_ptsz",
+    "cuMemAdvise",
+    "cuMemRangeGetAttribute",
+    "cuMemRangeGetAttributes",
+    "cuPointerSetAttribute",
+    "cuPointerGetAttributes",
+    "cuStreamCreate",
+    "cuStreamCreateWithPriority",
+    "cuStreamGetPriority_ptsz",
+    "cuStreamGetFlags_ptsz",
+    "cuStreamGetCtx_ptsz",
+    "cuStreamWaitEvent_ptsz",
+    "cuStreamAddCallback_ptsz",
+    "cuStreamBeginCapture_v2_ptsz",
+    "cuThreadExchangeStreamCaptureMode",
+    "cuStreamEndCapture_ptsz",
+    "cuStreamIsCapturing_ptsz",
+    "cuStreamGetCaptureInfo_ptsz",
+    "cuStreamAttachMemAsync_ptsz",
+    "cuStreamQuery_ptsz",
+    "cuStreamSynchronize_ptsz",
+    "cuStreamDestroy_v2",
+    "cuStreamCopyAttributes_ptsz",
+    "cuStreamGetAttribute_ptsz",
+    "cuStreamSetAttribute_ptsz",
+    "cuEventCreate",
+    "cuEventRecord_ptsz",
+    "cuEventRecordWithFlags_ptsz",
+    "cuEventQuery",
+    "cuEventSynchronize",
+    "cuEventDestroy_v2",
+    "cuEventElapsedTime",
+    "cuImportExternalMemory",
+    "cuExternalMemoryGetMappedBuffer",
+    "cuExternalMemoryGetMappedMipmappedArray",
+    "cuDestroyExternalMemory",
+    "cuImportExternalSemaphore",
+    "cuSignalExternalSemaphoresAsync_ptsz",
+    "cuWaitExternalSemaphoresAsync_ptsz",
+    "cuDestroyExternalSemaphore",
+    "cuStreamWaitValue32_ptsz",
+    "cuStreamWaitValue64_ptsz",
+    "cuStreamWriteValue32_ptsz",
+    "cuStreamWriteValue64_ptsz",
+    "cuStreamBatchMemOp_ptsz",
+    "cuFuncGetAttribute",
+    "cuFuncSetAttribute",
+    "cuFuncSetCacheConfig",
+    "cuFuncSetSharedMemConfig",
+    "cuLaunchKernel_ptsz",
+    "cuLaunchCooperativeKernel_ptsz",
+    "cuLaunchCooperativeKernelMultiDevice",
+    "cuLaunchHostFunc_ptsz",
+    "cuFuncSetBlockShape",
+    "cuFuncSetSharedSize",
+    "cuParamSetSize",
+    "cuParamSeti",
+    "cuParamSetf",
+    "cuParamSetv",
+    "cuLaunch",
+    "cuLaunchGrid",
+    "cuLaunchGridAsync",
+    "cuParamSetTexRef",
+    "cuGraphCreate",
+    "cuGraphAddKernelNode",
+    "cuGraphKernelNodeGetParams",
+    "cuGraphKernelNodeSetParams",
+    "cuGraphAddMemcpyNode",
+    "cuGraphMemcpyNodeGetParams",
+    "cuGraphMemcpyNodeSetParams",
+    "cuGraphAddMemsetNode",
+    "cuGraphMemsetNodeGetParams",
+    "cuGraphMemsetNodeSetParams",
+    "cuGraphAddHostNode",
+    "cuGraphHostNodeGetParams",
+    "cuGraphHostNodeSetParams",
+    "cuGraphAddChildGraphNode",
+    "cuGraphChildGraphNodeGetGraph",
+    "cuGraphAddEmptyNode",
+    "cuGraphAddEventRecordNode",
+    "cuGraphEventRecordNodeGetEvent",
+    "cuGraphEventRecordNodeSetEvent",
+    "cuGraphAddEventWaitNode",
+    "cuGraphEventWaitNodeGetEvent",
+    "cuGraphEventWaitNodeSetEvent",
+    "cuGraphAddExternalSemaphoresSignalNode",
+    "cuGraphExternalSemaphoresSignalNodeGetParams",
+    "cuGraphExternalSemaphoresSignalNodeSetParams",
+    "cuGraphAddExternalSemaphoresWaitNode",
+    "cuGraphExternalSemaphoresWaitNodeGetParams",
+    "cuGraphExternalSemaphoresWaitNodeSetParams",
+    "cuGraphClone",
+    "cuGraphNodeFindInClone",
+    "cuGraphNodeGetType",
+    "cuGraphGetNodes",
+    "cuGraphGetRootNodes",
+    "cuGraphGetEdges",
+    "cuGraphNodeGetDependencies",
+    "cuGraphNodeGetDependentNodes",
+    "cuGraphAddDependencies",
+    "cuGraphRemoveDependencies",
+    "cuGraphDestroyNode",
+    "cuGraphInstantiate_v2",
+    "cuGraphExecKernelNodeSetParams",
+    "cuGraphExecMemcpyNodeSetParams",
+    "cuGraphExecMemsetNodeSetParams",
+    "cuGraphExecHostNodeSetParams",
+    "cuGraphExecChildGraphNodeSetParams",
+    "cuGraphExecEventRecordNodeSetEvent",
+    "cuGraphExecEventWaitNodeSetEvent",
+    "cuGraphExecExternalSemaphoresSignalNodeSetParams",
+    "cuGraphExecExternalSemaphoresWaitNodeSetParams",
+    "cuGraphUpload_ptsz",
+    "cuGraphLaunch_ptsz",
+    "cuGraphExecDestroy",
+    "cuGraphDestroy",
+    "cuGraphExecUpdate",
+    "cuGraphKernelNodeCopyAttributes",
+    "cuGraphKernelNodeGetAttribute",
+    "cuGraphKernelNodeSetAttribute",
+    "cuOccupancyMaxActiveBlocksPerMultiprocessor",
+    "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags",
+    "cuOccupancyMaxPotentialBlockSize",
+    "cuOccupancyMaxPotentialBlockSizeWithFlags",
+    "cuOccupancyAvailableDynamicSMemPerBlock",
+    "cuTexRefSetArray",
+    "cuTexRefSetMipmappedArray",
+    "cuTexRefSetAddress_v2",
+    "cuTexRefSetAddress2D_v3",
+    "cuTexRefSetFormat",
+    "cuTexRefSetAddressMode",
+    "cuTexRefSetFilterMode",
+    "cuTexRefSetMipmapFilterMode",
+    "cuTexRefSetMipmapLevelBias",
+    "cuTexRefSetMipmapLevelClamp",
+    "cuTexRefSetMaxAnisotropy",
+    "cuTexRefSetBorderColor",
+    "cuTexRefSetFlags",
+    "cuTexRefGetAddress_v2",
+    "cuTexRefGetArray",
+    "cuTexRefGetMipmappedArray",
+    "cuTexRefGetAddressMode",
+    "cuTexRefGetFilterMode",
+    "cuTexRefGetFormat",
+    "cuTexRefGetMipmapFilterMode",
+    "cuTexRefGetMipmapLevelBias",
+    "cuTexRefGetMipmapLevelClamp",
+    "cuTexRefGetMaxAnisotropy",
+    "cuTexRefGetBorderColor",
+    "cuTexRefGetFlags",
+    "cuTexRefCreate",
+    "cuTexRefDestroy",
+    "cuSurfRefSetArray",
+    "cuSurfRefGetArray",
+    "cuTexObjectCreate",
+    "cuTexObjectDestroy",
+    "cuTexObjectGetResourceDesc",
+    "cuTexObjectGetTextureDesc",
+    "cuTexObjectGetResourceViewDesc",
+    "cuSurfObjectCreate",
+    "cuSurfObjectDestroy",
+    "cuSurfObjectGetResourceDesc",
+    "cuDeviceCanAccessPeer",
+    "cuCtxEnablePeerAccess",
+    "cuCtxDisablePeerAccess",
+    "cuDeviceGetP2PAttribute",
+    "cuGraphicsUnregisterResource",
+    "cuGraphicsSubResourceGetMappedArray",
+    "cuGraphicsResourceGetMappedMipmappedArray",
+    "cuGraphicsResourceGetMappedPointer_v2",
+    "cuGraphicsResourceSetMapFlags_v2",
+    "cuGraphicsMapResources_ptsz",
+    "cuGraphicsUnmapResources_ptsz",
+    "cuGetExportTable",
+    "cuFuncGetModule",
+    "cuMemHostRegister",
+    "cuGraphicsResourceSetMapFlags",
+    "cuLinkCreate",
+    "cuLinkAddData",
+    "cuLinkAddFile",
+    "cuTexRefSetAddress2D_v2",
+    "cuDeviceTotalMem",
+    "cuCtxCreate",
+    "cuModuleGetGlobal",
+    "cuMemGetInfo",
+    "cuMemAlloc",
+    "cuMemAllocPitch",
+    "cuMemFree",
+    "cuMemGetAddressRange",
+    "cuMemAllocHost",
+    "cuMemHostGetDevicePointer",
+    "cuMemcpyHtoD",
+    "cuMemcpyDtoH",
+    "cuMemcpyDtoD",
+    "cuMemcpyDtoA",
+    "cuMemcpyAtoD",
+    "cuMemcpyHtoA",
+    "cuMemcpyAtoH",
+    "cuMemcpyAtoA",
+    "cuMemcpyHtoAAsync",
+    "cuMemcpyAtoHAsync",
+    "cuMemcpy2D",
+    "cuMemcpy2DUnaligned",
+    "cuMemcpy3D",
+    "cuMemcpyHtoDAsync",
+    "cuMemcpyDtoHAsync",
+    "cuMemcpyDtoDAsync",
+    "cuMemcpy2DAsync",
+    "cuMemcpy3DAsync",
+    "cuMemsetD8",
+    "cuMemsetD16",
+    "cuMemsetD32",
+    "cuMemsetD2D8",
+    "cuMemsetD2D16",
+    "cuMemsetD2D32",
+    "cuArrayCreate",
+    "cuArrayGetDescriptor",
+    "cuArray3DCreate",
+    "cuArray3DGetDescriptor",
+    "cuTexRefSetAddress",
+    "cuTexRefSetAddress2D",
+    "cuTexRefGetAddress",
+    "cuGraphicsResourceGetMappedPointer",
+    "cuCtxDestroy",
+    "cuCtxPopCurrent",
+    "cuCtxPushCurrent",
+    "cuStreamDestroy",
+    "cuEventDestroy",
+    "cuDevicePrimaryCtxRelease",
+    "cuDevicePrimaryCtxReset",
+    "cuDevicePrimaryCtxSetFlags",
+    "cuMemcpyHtoD_v2",
+    "cuMemcpyDtoH_v2",
+    "cuMemcpyDtoD_v2",
+    "cuMemcpyDtoA_v2",
+    "cuMemcpyAtoD_v2",
+    "cuMemcpyHtoA_v2",
+    "cuMemcpyAtoH_v2",
+    "cuMemcpyAtoA_v2",
+    "cuMemcpyHtoAAsync_v2",
+    "cuMemcpyAtoHAsync_v2",
+    "cuMemcpy2D_v2",
+    "cuMemcpy2DUnaligned_v2",
+    "cuMemcpy3D_v2",
+    "cuMemcpyHtoDAsync_v2",
+    "cuMemcpyDtoHAsync_v2",
+    "cuMemcpyDtoDAsync_v2",
+    "cuMemcpy2DAsync_v2",
+    "cuMemcpy3DAsync_v2",
+    "cuMemsetD8_v2",
+    "cuMemsetD16_v2",
+    "cuMemsetD32_v2",
+    "cuMemsetD2D8_v2",
+    "cuMemsetD2D16_v2",
+    "cuMemsetD2D32_v2",
+    "cuMemcpy",
+    "cuMemcpyAsync",
+    "cuMemcpyPeer",
+    "cuMemcpyPeerAsync",
+    "cuMemcpy3DPeer",
+    "cuMemcpy3DPeerAsync",
+    "cuMemsetD8Async",
+    "cuMemsetD16Async",
+    "cuMemsetD32Async",
+    "cuMemsetD2D8Async",
+    "cuMemsetD2D16Async",
+    "cuMemsetD2D32Async",
+    "cuStreamGetPriority",
+    "cuStreamGetFlags",
+    "cuStreamGetCtx",
+    "cuStreamWaitEvent",
+    "cuStreamAddCallback",
+    "cuStreamAttachMemAsync",
+    "cuStreamQuery",
+    "cuStreamSynchronize",
+    "cuEventRecord",
+    "cuEventRecordWithFlags",
+    "cuLaunchKernel",
+    "cuLaunchHostFunc",
+    "cuGraphicsMapResources",
+    "cuGraphicsUnmapResources",
+    "cuStreamWriteValue32",
+    "cuStreamWaitValue32",
+    "cuStreamWriteValue64",
+    "cuStreamWaitValue64",
+    "cuStreamBatchMemOp",
+    "cuMemPrefetchAsync",
+    "cuLaunchCooperativeKernel",
+    "cuSignalExternalSemaphoresAsync",
+    "cuWaitExternalSemaphoresAsync",
+    "cuStreamBeginCapture",
+    "cuStreamBeginCapture_ptsz",
+    "cuStreamBeginCapture_v2",
+    "cuStreamEndCapture",
+    "cuStreamIsCapturing",
+    "cuStreamGetCaptureInfo",
+    "cuGraphUpload",
+    "cuGraphLaunch",
+    "cuStreamCopyAttributes",
+    "cuStreamGetAttribute",
+    "cuStreamSetAttribute",
+    "cuIpcOpenMemHandle",
+    "cuGraphInstantiate",
+    "cuMemMapArrayAsync",
+    "cuMemFreeAsync",
+    "cuMemAllocAsync",
+    "cuMemAllocFromPoolAsync",
+    "cuProfilerInitialize",
+    "cuProfilerStart",
+    "cuProfilerStop"};
+
+static void load_library() {
+    static bool done = false;
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lg{mtx};
+
+    if (done)
+        return;
+
+    void* handle = get_library_handle();
+    for (size_t i = 0; i < NR_FUNC; ++i) {
+        void* func;
+        if (!handle) {
+            func = nullptr;
+        } else {
+            func = resolve_library_func(handle, g_func_name[i]);
+        }
+        if (!func) {
+            func = g_func_table_error[i];
+        }
+        __atomic_store_n(g_func_table + i, func, __ATOMIC_RELAXED);
+    }
+    done = true;
+}
+
+CUresult _WRAPLIB_API_CALL cuGetErrorString(CUresult arg0, const char **arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUresult, const char **);
+    ON_ENTRY(cuGetErrorString);
+    f_ptr_t f = (f_ptr_t)(g_func_table[0]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGetErrorName(CUresult arg0, const char **arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUresult, const char **);
+    ON_ENTRY(cuGetErrorName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[1]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuInit(unsigned int arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int);
+    ON_ENTRY(cuInit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[2]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDriverGetVersion(int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *);
+    ON_ENTRY(cuDriverGetVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[3]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGet(CUdevice *arg0, int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, int);
+    ON_ENTRY(cuDeviceGet);
+    f_ptr_t f = (f_ptr_t)(g_func_table[4]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetCount(int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *);
+    ON_ENTRY(cuDeviceGetCount);
+    f_ptr_t f = (f_ptr_t)(g_func_table[5]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetName(char *arg0, int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
+    ON_ENTRY(cuDeviceGetName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[6]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetUuid(CUuuid *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUuuid *, CUdevice);
+    ON_ENTRY(cuDeviceGetUuid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetLuid(char *arg0, unsigned int *arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, unsigned int *, CUdevice);
+    ON_ENTRY(cuDeviceGetLuid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceTotalMem_v2(size_t *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUdevice);
+    ON_ENTRY(cuDeviceTotalMem_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetTexture1DLinearMaxWidth(size_t *arg0, CUarray_format arg1, unsigned arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUarray_format, unsigned, CUdevice);
+    ON_ENTRY(cuDeviceGetTexture1DLinearMaxWidth);
+    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetAttribute(int *arg0, CUdevice_attribute arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_attribute, CUdevice);
+    ON_ENTRY(cuDeviceGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetNvSciSyncAttributes(void *arg0, CUdevice arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdevice, int);
+    ON_ENTRY(cuDeviceGetNvSciSyncAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceSetMemPool(CUdevice arg0, CUmemoryPool arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, CUmemoryPool);
+    ON_ENTRY(cuDeviceSetMemPool);
+    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetMemPool(CUmemoryPool *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool *, CUdevice);
+    ON_ENTRY(cuDeviceGetMemPool);
+    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetDefaultMemPool(CUmemoryPool *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool *, CUdevice);
+    ON_ENTRY(cuDeviceGetDefaultMemPool);
+    f_ptr_t f = (f_ptr_t)(g_func_table[15]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetProperties(CUdevprop *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevprop *, CUdevice);
+    ON_ENTRY(cuDeviceGetProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[16]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceComputeCapability(int *arg0, int *arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUdevice);
+    ON_ENTRY(cuDeviceComputeCapability);
+    f_ptr_t f = (f_ptr_t)(g_func_table[17]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRetain(CUcontext *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRetain);
+    f_ptr_t f = (f_ptr_t)(g_func_table[18]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease_v2(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRelease_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[19]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags_v2(CUdevice arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int);
+    ON_ENTRY(cuDevicePrimaryCtxSetFlags_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxGetState(CUdevice arg0, unsigned int *arg1, int *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int *, int *);
+    ON_ENTRY(cuDevicePrimaryCtxGetState);
+    f_ptr_t f = (f_ptr_t)(g_func_table[21]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset_v2(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxReset_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[22]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxCreate_v2(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
+    ON_ENTRY(cuCtxCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[23]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDestroy_v2(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[24]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPushCurrent_v2(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxPushCurrent_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[25]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPopCurrent_v2(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxPopCurrent_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[26]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetCurrent(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxSetCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[27]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetCurrent(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxGetCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[28]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetDevice(CUdevice *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *);
+    ON_ENTRY(cuCtxGetDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[29]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetFlags(unsigned int *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *);
+    ON_ENTRY(cuCtxGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[30]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSynchronize() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuCtxSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[31]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetLimit(CUlimit arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlimit, size_t);
+    ON_ENTRY(cuCtxSetLimit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[32]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetLimit(size_t *arg0, CUlimit arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUlimit);
+    ON_ENTRY(cuCtxGetLimit);
+    f_ptr_t f = (f_ptr_t)(g_func_table[33]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetCacheConfig(CUfunc_cache *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache *);
+    ON_ENTRY(cuCtxGetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[34]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetCacheConfig(CUfunc_cache arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunc_cache);
+    ON_ENTRY(cuCtxSetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[35]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetSharedMemConfig(CUsharedconfig *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig *);
+    ON_ENTRY(cuCtxGetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[36]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxSetSharedMemConfig(CUsharedconfig arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsharedconfig);
+    ON_ENTRY(cuCtxSetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[37]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetApiVersion(CUcontext arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int *);
+    ON_ENTRY(cuCtxGetApiVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[38]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxGetStreamPriorityRange(int *arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *);
+    ON_ENTRY(cuCtxGetStreamPriorityRange);
+    f_ptr_t f = (f_ptr_t)(g_func_table[39]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxResetPersistingL2Cache() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuCtxResetPersistingL2Cache);
+    f_ptr_t f = (f_ptr_t)(g_func_table[40]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuCtxAttach(CUcontext *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int);
+    ON_ENTRY(cuCtxAttach);
+    f_ptr_t f = (f_ptr_t)(g_func_table[41]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDetach(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDetach);
+    f_ptr_t f = (f_ptr_t)(g_func_table[42]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoad(CUmodule *arg0, const char *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const char *);
+    ON_ENTRY(cuModuleLoad);
+    f_ptr_t f = (f_ptr_t)(g_func_table[43]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadData(CUmodule *arg0, const void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
+    ON_ENTRY(cuModuleLoadData);
+    f_ptr_t f = (f_ptr_t)(g_func_table[44]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadDataEx(CUmodule *arg0, const void *arg1, unsigned int arg2, CUjit_option *arg3, void **arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuModuleLoadDataEx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[45]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuModuleLoadFatBinary(CUmodule *arg0, const void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, const void *);
+    ON_ENTRY(cuModuleLoadFatBinary);
+    f_ptr_t f = (f_ptr_t)(g_func_table[46]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuModuleUnload(CUmodule arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule);
+    ON_ENTRY(cuModuleUnload);
+    f_ptr_t f = (f_ptr_t)(g_func_table[47]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetFunction(CUfunction *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetFunction);
+    f_ptr_t f = (f_ptr_t)(g_func_table[48]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetGlobal_v2(CUdeviceptr *arg0, size_t *arg1, CUmodule arg2, const char *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetGlobal_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[49]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetTexRef(CUtexref *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetTexRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[50]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetSurfRef(CUsurfref *arg0, CUmodule arg1, const char *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetSurfRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[51]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLinkCreate_v2(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
+    ON_ENTRY(cuLinkCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[52]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddData_v2(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddData_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[53]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddFile_v2(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddFile_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[54]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuLinkComplete(CUlinkState arg0, void **arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, void **, size_t *);
+    ON_ENTRY(cuLinkComplete);
+    f_ptr_t f = (f_ptr_t)(g_func_table[55]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLinkDestroy(CUlinkState arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState);
+    ON_ENTRY(cuLinkDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[56]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetInfo_v2(size_t *arg0, size_t *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, size_t *);
+    ON_ENTRY(cuMemGetInfo_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[57]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAlloc_v2(CUdeviceptr *arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t);
+    ON_ENTRY(cuMemAlloc_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[58]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocPitch_v2(CUdeviceptr *arg0, size_t *arg1, size_t arg2, size_t arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, size_t, size_t, unsigned int);
+    ON_ENTRY(cuMemAllocPitch_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[59]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemFree_v2(CUdeviceptr arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
+    ON_ENTRY(cuMemFree_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[60]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAddressRange_v2(CUdeviceptr *arg0, size_t *arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUdeviceptr);
+    ON_ENTRY(cuMemGetAddressRange_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[61]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocHost_v2(void **arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t);
+    ON_ENTRY(cuMemAllocHost_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[62]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemFreeHost(void *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
+    ON_ENTRY(cuMemFreeHost);
+    f_ptr_t f = (f_ptr_t)(g_func_table[63]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostAlloc(void **arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t, unsigned int);
+    ON_ENTRY(cuMemHostAlloc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[64]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer_v2(CUdeviceptr *arg0, void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, void *, unsigned int);
+    ON_ENTRY(cuMemHostGetDevicePointer_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[65]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetFlags(unsigned int *arg0, void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, void *);
+    ON_ENTRY(cuMemHostGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[66]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocManaged(CUdeviceptr *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, unsigned int);
+    ON_ENTRY(cuMemAllocManaged);
+    f_ptr_t f = (f_ptr_t)(g_func_table[67]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetByPCIBusId(CUdevice *arg0, const char *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice *, const char *);
+    ON_ENTRY(cuDeviceGetByPCIBusId);
+    f_ptr_t f = (f_ptr_t)(g_func_table[68]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetPCIBusId(char *arg0, int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(char *, int, CUdevice);
+    ON_ENTRY(cuDeviceGetPCIBusId);
+    f_ptr_t f = (f_ptr_t)(g_func_table[69]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcGetEventHandle(CUipcEventHandle *arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcEventHandle *, CUevent);
+    ON_ENTRY(cuIpcGetEventHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[70]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenEventHandle(CUevent *arg0, CUipcEventHandle arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, CUipcEventHandle);
+    ON_ENTRY(cuIpcOpenEventHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[71]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcGetMemHandle(CUipcMemHandle *arg0, CUdeviceptr arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUipcMemHandle *, CUdeviceptr);
+    ON_ENTRY(cuIpcGetMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[72]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle_v2(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUipcMemHandle, unsigned int);
+    ON_ENTRY(cuIpcOpenMemHandle_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[73]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcCloseMemHandle(CUdeviceptr arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr);
+    ON_ENTRY(cuIpcCloseMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[74]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostRegister_v2(void *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
+    ON_ENTRY(cuMemHostRegister_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[75]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostUnregister(void *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *);
+    ON_ENTRY(cuMemHostUnregister);
+    f_ptr_t f = (f_ptr_t)(g_func_table[76]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpy_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[77]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeer_ptds(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
+    ON_ENTRY(cuMemcpyPeer_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[78]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2_ptds(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[79]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2_ptds(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoH_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[80]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2_ptds(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[81]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2_ptds(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[82]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2_ptds(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoD_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[83]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2_ptds(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[84]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2_ptds(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoH_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[85]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2_ptds(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoA_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[86]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2_ptds(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2D_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[87]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2_ptds(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2DUnaligned_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[88]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2_ptds(const CUDA_MEMCPY3D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuMemcpy3D_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[89]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer_ptds(const CUDA_MEMCPY3D_PEER *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
+    ON_ENTRY(cuMemcpy3DPeer_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[90]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAsync_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[91]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync_ptsz(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
+    ON_ENTRY(cuMemcpyPeerAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[92]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2_ptsz(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[93]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2_ptsz(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[94]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2_ptsz(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[95]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2_ptsz(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[96]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2_ptsz(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[97]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2_ptsz(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[98]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2_ptsz(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[99]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync_ptsz(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
+    ON_ENTRY(cuMemcpy3DPeerAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[100]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8_v2_ptds(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
+    ON_ENTRY(cuMemsetD8_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[101]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16_v2_ptds(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
+    ON_ENTRY(cuMemsetD16_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[102]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32_v2_ptds(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
+    ON_ENTRY(cuMemsetD32_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[103]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D8_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[104]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D16_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[105]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2_ptds(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D32_v2_ptds);
+    f_ptr_t f = (f_ptr_t)(g_func_table[106]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8Async_ptsz(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
+    ON_ENTRY(cuMemsetD8Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[107]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16Async_ptsz(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
+    ON_ENTRY(cuMemsetD16Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[108]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32Async_ptsz(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
+    ON_ENTRY(cuMemsetD32Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[109]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D8Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[110]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D16Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[111]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async_ptsz(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D32Async_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[112]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuArrayCreate_v2(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR *);
+    ON_ENTRY(cuArrayCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[113]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor_v2(CUDA_ARRAY_DESCRIPTOR *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR *, CUarray);
+    ON_ENTRY(cuArrayGetDescriptor_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[114]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_SPARSE_PROPERTIES *, CUarray);
+    ON_ENTRY(cuArrayGetSparseProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[115]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES *arg0, CUmipmappedArray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_SPARSE_PROPERTIES *, CUmipmappedArray);
+    ON_ENTRY(cuMipmappedArrayGetSparseProperties);
+    f_ptr_t f = (f_ptr_t)(g_func_table[116]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetPlane(CUarray *arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUarray, unsigned int);
+    ON_ENTRY(cuArrayGetPlane);
+    f_ptr_t f = (f_ptr_t)(g_func_table[117]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuArrayDestroy(CUarray arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray);
+    ON_ENTRY(cuArrayDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[118]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DCreate_v2(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *);
+    ON_ENTRY(cuArray3DCreate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[119]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor_v2(CUDA_ARRAY3D_DESCRIPTOR *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR *, CUarray);
+    ON_ENTRY(cuArray3DGetDescriptor_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[120]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayCreate(CUmipmappedArray *arg0, const CUDA_ARRAY3D_DESCRIPTOR *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int);
+    ON_ENTRY(cuMipmappedArrayCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[121]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayGetLevel(CUarray *arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUmipmappedArray, unsigned int);
+    ON_ENTRY(cuMipmappedArrayGetLevel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[122]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMipmappedArrayDestroy(CUmipmappedArray arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray);
+    ON_ENTRY(cuMipmappedArrayDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[123]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemAddressReserve(CUdeviceptr *arg0, size_t arg1, size_t arg2, CUdeviceptr arg3, unsigned long long arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, size_t, CUdeviceptr, unsigned long long);
+    ON_ENTRY(cuMemAddressReserve);
+    f_ptr_t f = (f_ptr_t)(g_func_table[124]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemAddressFree(CUdeviceptr arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t);
+    ON_ENTRY(cuMemAddressFree);
+    f_ptr_t f = (f_ptr_t)(g_func_table[125]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemCreate(CUmemGenericAllocationHandle *arg0, size_t arg1, const CUmemAllocationProp *arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, size_t, const CUmemAllocationProp *, unsigned long long);
+    ON_ENTRY(cuMemCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[126]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemRelease(CUmemGenericAllocationHandle arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle);
+    ON_ENTRY(cuMemRelease);
+    f_ptr_t f = (f_ptr_t)(g_func_table[127]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemMap(CUdeviceptr arg0, size_t arg1, size_t arg2, CUmemGenericAllocationHandle arg3, unsigned long long arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long);
+    ON_ENTRY(cuMemMap);
+    f_ptr_t f = (f_ptr_t)(g_func_table[128]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync_ptsz(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarrayMapInfo *, unsigned int, CUstream);
+    ON_ENTRY(cuMemMapArrayAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[129]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemUnmap(CUdeviceptr arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t);
+    ON_ENTRY(cuMemUnmap);
+    f_ptr_t f = (f_ptr_t)(g_func_table[130]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemSetAccess(CUdeviceptr arg0, size_t arg1, const CUmemAccessDesc *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, const CUmemAccessDesc *, size_t);
+    ON_ENTRY(cuMemSetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[131]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAccess(unsigned long long *arg0, const CUmemLocation *arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned long long *, const CUmemLocation *, CUdeviceptr);
+    ON_ENTRY(cuMemGetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[132]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemExportToShareableHandle(void *arg0, CUmemGenericAllocationHandle arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long);
+    ON_ENTRY(cuMemExportToShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[133]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemImportFromShareableHandle(CUmemGenericAllocationHandle *arg0, void *arg1, CUmemAllocationHandleType arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, void *, CUmemAllocationHandleType);
+    ON_ENTRY(cuMemImportFromShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[134]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAllocationGranularity(size_t *arg0, const CUmemAllocationProp *arg1, CUmemAllocationGranularity_flags arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, const CUmemAllocationProp *, CUmemAllocationGranularity_flags);
+    ON_ENTRY(cuMemGetAllocationGranularity);
+    f_ptr_t f = (f_ptr_t)(g_func_table[135]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp *arg0, CUmemGenericAllocationHandle arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemAllocationProp *, CUmemGenericAllocationHandle);
+    ON_ENTRY(cuMemGetAllocationPropertiesFromHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[136]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemRetainAllocationHandle(CUmemGenericAllocationHandle *arg0, void *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemGenericAllocationHandle *, void *);
+    ON_ENTRY(cuMemRetainAllocationHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[137]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemFreeAsync_ptsz(CUdeviceptr arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUstream);
+    ON_ENTRY(cuMemFreeAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[138]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocAsync_ptsz(CUdeviceptr *arg0, size_t arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, CUstream);
+    ON_ENTRY(cuMemAllocAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[139]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolTrimTo(CUmemoryPool arg0, size_t arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool, size_t);
+    ON_ENTRY(cuMemPoolTrimTo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[140]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolSetAttribute(CUmemoryPool arg0, CUmemPool_attribute arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool, CUmemPool_attribute, void *);
+    ON_ENTRY(cuMemPoolSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[141]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolGetAttribute(CUmemoryPool arg0, CUmemPool_attribute arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool, CUmemPool_attribute, void *);
+    ON_ENTRY(cuMemPoolGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[142]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolSetAccess(CUmemoryPool arg0, const CUmemAccessDesc *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool, const CUmemAccessDesc *, size_t);
+    ON_ENTRY(cuMemPoolSetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[143]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolGetAccess(CUmemAccess_flags *arg0, CUmemoryPool arg1, CUmemLocation *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemAccess_flags *, CUmemoryPool, CUmemLocation *);
+    ON_ENTRY(cuMemPoolGetAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[144]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolCreate(CUmemoryPool *arg0, const CUmemPoolProps *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool *, const CUmemPoolProps *);
+    ON_ENTRY(cuMemPoolCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[145]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolDestroy(CUmemoryPool arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool);
+    ON_ENTRY(cuMemPoolDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[146]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocFromPoolAsync_ptsz(CUdeviceptr *arg0, size_t arg1, CUmemoryPool arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, CUmemoryPool, CUstream);
+    ON_ENTRY(cuMemAllocFromPoolAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[147]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolExportToShareableHandle(void *arg0, CUmemoryPool arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUmemoryPool, CUmemAllocationHandleType, unsigned long long);
+    ON_ENTRY(cuMemPoolExportToShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[148]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolImportFromShareableHandle(CUmemoryPool *arg0, void *arg1, CUmemAllocationHandleType arg2, unsigned long long arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemoryPool *, void *, CUmemAllocationHandleType, unsigned long long);
+    ON_ENTRY(cuMemPoolImportFromShareableHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[149]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolExportPointer(CUmemPoolPtrExportData *arg0, CUdeviceptr arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmemPoolPtrExportData *, CUdeviceptr);
+    ON_ENTRY(cuMemPoolExportPointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[150]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemPoolImportPointer(CUdeviceptr *arg0, CUmemoryPool arg1, CUmemPoolPtrExportData *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUmemoryPool, CUmemPoolPtrExportData *);
+    ON_ENTRY(cuMemPoolImportPointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[151]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuPointerGetAttribute(void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUpointer_attribute, CUdeviceptr);
+    ON_ENTRY(cuPointerGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[152]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync_ptsz(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[153]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemAdvise(CUdeviceptr arg0, size_t arg1, CUmem_advise arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUmem_advise, CUdevice);
+    ON_ENTRY(cuMemAdvise);
+    f_ptr_t f = (f_ptr_t)(g_func_table[154]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemRangeGetAttribute(void *arg0, size_t arg1, CUmem_range_attribute arg2, CUdeviceptr arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, CUmem_range_attribute, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemRangeGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[155]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemRangeGetAttributes(void **arg0, size_t *arg1, CUmem_range_attribute *arg2, size_t arg3, CUdeviceptr arg4, size_t arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemRangeGetAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[156]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuPointerSetAttribute(const void *arg0, CUpointer_attribute arg1, CUdeviceptr arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void *, CUpointer_attribute, CUdeviceptr);
+    ON_ENTRY(cuPointerSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[157]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuPointerGetAttributes(unsigned int arg0, CUpointer_attribute *arg1, void **arg2, CUdeviceptr arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUpointer_attribute *, void **, CUdeviceptr);
+    ON_ENTRY(cuPointerGetAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[158]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCreate(CUstream *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int);
+    ON_ENTRY(cuStreamCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[159]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCreateWithPriority(CUstream *arg0, unsigned int arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream *, unsigned int, int);
+    ON_ENTRY(cuStreamCreateWithPriority);
+    f_ptr_t f = (f_ptr_t)(g_func_table[160]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetPriority_ptsz(CUstream arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
+    ON_ENTRY(cuStreamGetPriority_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[161]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetFlags_ptsz(CUstream arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
+    ON_ENTRY(cuStreamGetFlags_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[162]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx_ptsz(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[163]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitEvent_ptsz(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
+    ON_ENTRY(cuStreamWaitEvent_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[164]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAddCallback_ptsz(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
+    ON_ENTRY(cuStreamAddCallback_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[165]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2_ptsz(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[166]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstreamCaptureMode *);
+    ON_ENTRY(cuThreadExchangeStreamCaptureMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[167]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture_ptsz(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[168]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[169]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo_ptsz(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[170]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync_ptsz(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
+    ON_ENTRY(cuStreamAttachMemAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[171]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamQuery_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamQuery_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[172]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSynchronize_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamSynchronize_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[173]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamDestroy_v2(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[174]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes_ptsz(CUstream arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstream);
+    ON_ENTRY(cuStreamCopyAttributes_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[175]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetAttribute_ptsz(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, CUstreamAttrValue *);
+    ON_ENTRY(cuStreamGetAttribute_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[176]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSetAttribute_ptsz(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, const CUstreamAttrValue *);
+    ON_ENTRY(cuStreamSetAttribute_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[177]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuEventCreate(CUevent *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent *, unsigned int);
+    ON_ENTRY(cuEventCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[178]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecord_ptsz(CUevent arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
+    ON_ENTRY(cuEventRecord_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[179]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags_ptsz(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream, unsigned int);
+    ON_ENTRY(cuEventRecordWithFlags_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[180]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuEventQuery(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventQuery);
+    f_ptr_t f = (f_ptr_t)(g_func_table[181]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventSynchronize(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[182]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventDestroy_v2(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventDestroy_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[183]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventElapsedTime(float *arg0, CUevent arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUevent, CUevent);
+    ON_ENTRY(cuEventElapsedTime);
+    f_ptr_t f = (f_ptr_t)(g_func_table[184]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalMemory(CUexternalMemory *arg0, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory *, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[185]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedBuffer(CUdeviceptr *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedBuffer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[186]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray *arg0, CUexternalMemory arg1, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *);
+    ON_ENTRY(cuExternalMemoryGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[187]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalMemory(CUexternalMemory arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalMemory);
+    ON_ENTRY(cuDestroyExternalMemory);
+    f_ptr_t f = (f_ptr_t)(g_func_table[188]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuImportExternalSemaphore(CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *);
+    ON_ENTRY(cuImportExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[189]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[190]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync_ptsz(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[191]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDestroyExternalSemaphore(CUexternalSemaphore arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUexternalSemaphore);
+    ON_ENTRY(cuDestroyExternalSemaphore);
+    f_ptr_t f = (f_ptr_t)(g_func_table[192]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue32_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[193]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[194]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue32_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue32_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[195]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64_ptsz(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[196]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp_ptsz(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
+    ON_ENTRY(cuStreamBatchMemOp_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[197]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuFuncGetAttribute(int *arg0, CUfunction_attribute arg1, CUfunction arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction_attribute, CUfunction);
+    ON_ENTRY(cuFuncGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[198]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetAttribute(CUfunction arg0, CUfunction_attribute arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunction_attribute, int);
+    ON_ENTRY(cuFuncSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[199]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetCacheConfig(CUfunction arg0, CUfunc_cache arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUfunc_cache);
+    ON_ENTRY(cuFuncSetCacheConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[200]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetSharedMemConfig(CUfunction arg0, CUsharedconfig arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, CUsharedconfig);
+    ON_ENTRY(cuFuncSetSharedMemConfig);
+    f_ptr_t f = (f_ptr_t)(g_func_table[201]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
+    ON_ENTRY(cuLaunchKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[202]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel_ptsz(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[203]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS *arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int);
+    ON_ENTRY(cuLaunchCooperativeKernelMultiDevice);
+    f_ptr_t f = (f_ptr_t)(g_func_table[204]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc_ptsz(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[205]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetBlockShape(CUfunction arg0, int arg1, int arg2, int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, int);
+    ON_ENTRY(cuFuncSetBlockShape);
+    f_ptr_t f = (f_ptr_t)(g_func_table[206]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuFuncSetSharedSize(CUfunction arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
+    ON_ENTRY(cuFuncSetSharedSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[207]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetSize(CUfunction arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int);
+    ON_ENTRY(cuParamSetSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[208]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuParamSeti(CUfunction arg0, int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, unsigned int);
+    ON_ENTRY(cuParamSeti);
+    f_ptr_t f = (f_ptr_t)(g_func_table[209]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetf(CUfunction arg0, int arg1, float arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, float);
+    ON_ENTRY(cuParamSetf);
+    f_ptr_t f = (f_ptr_t)(g_func_table[210]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetv(CUfunction arg0, int arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, void *, unsigned int);
+    ON_ENTRY(cuParamSetv);
+    f_ptr_t f = (f_ptr_t)(g_func_table[211]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLaunch(CUfunction arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction);
+    ON_ENTRY(cuLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[212]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchGrid(CUfunction arg0, int arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int);
+    ON_ENTRY(cuLaunchGrid);
+    f_ptr_t f = (f_ptr_t)(g_func_table[213]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchGridAsync(CUfunction arg0, int arg1, int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, int, CUstream);
+    ON_ENTRY(cuLaunchGridAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[214]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuParamSetTexRef(CUfunction arg0, int arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, int, CUtexref);
+    ON_ENTRY(cuParamSetTexRef);
+    f_ptr_t f = (f_ptr_t)(g_func_table[215]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphCreate(CUgraph *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, unsigned int);
+    ON_ENTRY(cuGraphCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[216]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddKernelNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_KERNEL_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddKernelNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[217]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetParams(CUgraphNode arg0, CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[218]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetParams(CUgraphNode arg0, const CUDA_KERNEL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[219]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemcpyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMCPY3D *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphAddMemcpyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[220]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeGetParams(CUgraphNode arg0, CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[221]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemcpyNodeSetParams(CUgraphNode arg0, const CUDA_MEMCPY3D *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuGraphMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[222]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddMemsetNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_MEMSET_NODE_PARAMS *arg4, CUcontext arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphAddMemsetNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[223]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeGetParams(CUgraphNode arg0, CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[224]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphMemsetNodeSetParams(CUgraphNode arg0, const CUDA_MEMSET_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *);
+    ON_ENTRY(cuGraphMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[225]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddHostNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_HOST_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddHostNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[226]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeGetParams(CUgraphNode arg0, CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[227]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphHostNodeSetParams(CUgraphNode arg0, const CUDA_HOST_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[228]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddChildGraphNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUgraph arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUgraph);
+    ON_ENTRY(cuGraphAddChildGraphNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[229]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphChildGraphNodeGetGraph(CUgraphNode arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraph *);
+    ON_ENTRY(cuGraphChildGraphNodeGetGraph);
+    f_ptr_t f = (f_ptr_t)(g_func_table[230]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEmptyNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddEmptyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[231]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEventRecordNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent);
+    ON_ENTRY(cuGraphAddEventRecordNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[232]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeGetEvent(CUgraphNode arg0, CUevent *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent *);
+    ON_ENTRY(cuGraphEventRecordNodeGetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[233]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventRecordNodeSetEvent(CUgraphNode arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphEventRecordNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[234]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddEventWaitNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, CUevent arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, CUevent);
+    ON_ENTRY(cuGraphAddEventWaitNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[235]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeGetEvent(CUgraphNode arg0, CUevent *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent *);
+    ON_ENTRY(cuGraphEventWaitNodeGetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[236]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphEventWaitNodeSetEvent(CUgraphNode arg0, CUevent arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphEventWaitNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[237]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddExternalSemaphoresSignalNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddExternalSemaphoresSignalNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[238]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresSignalNodeGetParams(CUgraphNode arg0, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExternalSemaphoresSignalNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[239]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresSignalNodeSetParams(CUgraphNode arg0, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExternalSemaphoresSignalNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[240]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddExternalSemaphoresWaitNode(CUgraphNode *arg0, CUgraph arg1, const CUgraphNode *arg2, size_t arg3, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraph, const CUgraphNode *, size_t, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *);
+    ON_ENTRY(cuGraphAddExternalSemaphoresWaitNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[241]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresWaitNodeGetParams(CUgraphNode arg0, CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExternalSemaphoresWaitNodeGetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[242]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExternalSemaphoresWaitNodeSetParams(CUgraphNode arg0, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExternalSemaphoresWaitNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[243]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphClone(CUgraph *arg0, CUgraph arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph *, CUgraph);
+    ON_ENTRY(cuGraphClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[244]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeFindInClone(CUgraphNode *arg0, CUgraphNode arg1, CUgraph arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode *, CUgraphNode, CUgraph);
+    ON_ENTRY(cuGraphNodeFindInClone);
+    f_ptr_t f = (f_ptr_t)(g_func_table[245]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetType(CUgraphNode arg0, CUgraphNodeType *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNodeType *);
+    ON_ENTRY(cuGraphNodeGetType);
+    f_ptr_t f = (f_ptr_t)(g_func_table[246]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[247]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetRootNodes(CUgraph arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetRootNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[248]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphGetEdges(CUgraph arg0, CUgraphNode *arg1, CUgraphNode *arg2, size_t *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, CUgraphNode *, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphGetEdges);
+    f_ptr_t f = (f_ptr_t)(g_func_table[249]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependencies(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[250]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphNodeGetDependentNodes(CUgraphNode arg0, CUgraphNode *arg1, size_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode *, size_t *);
+    ON_ENTRY(cuGraphNodeGetDependentNodes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[251]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphAddDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphAddDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[252]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphRemoveDependencies(CUgraph arg0, const CUgraphNode *arg1, const CUgraphNode *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph, const CUgraphNode *, const CUgraphNode *, size_t);
+    ON_ENTRY(cuGraphRemoveDependencies);
+    f_ptr_t f = (f_ptr_t)(g_func_table[253]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroyNode(CUgraphNode arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode);
+    ON_ENTRY(cuGraphDestroyNode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[254]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphInstantiate_v2(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t);
+    ON_ENTRY(cuGraphInstantiate_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[255]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecKernelNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_KERNEL_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecKernelNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[256]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecMemcpyNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMCPY3D *arg2, CUcontext arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D *, CUcontext);
+    ON_ENTRY(cuGraphExecMemcpyNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[257]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecMemsetNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_MEMSET_NODE_PARAMS *arg2, CUcontext arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS *, CUcontext);
+    ON_ENTRY(cuGraphExecMemsetNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[258]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecHostNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_HOST_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecHostNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[259]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecChildGraphNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, CUgraph arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, CUgraph);
+    ON_ENTRY(cuGraphExecChildGraphNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[260]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecEventRecordNodeSetEvent(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphExecEventRecordNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[261]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecEventWaitNodeSetEvent(CUgraphExec arg0, CUgraphNode arg1, CUevent arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, CUevent);
+    ON_ENTRY(cuGraphExecEventWaitNodeSetEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[262]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecExternalSemaphoresSignalNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecExternalSemaphoresSignalNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[263]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecExternalSemaphoresWaitNodeSetParams(CUgraphExec arg0, CUgraphNode arg1, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *);
+    ON_ENTRY(cuGraphExecExternalSemaphoresWaitNodeSetParams);
+    f_ptr_t f = (f_ptr_t)(g_func_table[264]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphUpload_ptsz(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphUpload_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[265]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch_ptsz(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[266]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecDestroy(CUgraphExec arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec);
+    ON_ENTRY(cuGraphExecDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[267]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphDestroy(CUgraph arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraph);
+    ON_ENTRY(cuGraphDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[268]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphExecUpdate(CUgraphExec arg0, CUgraph arg1, CUgraphNode *arg2, CUgraphExecUpdateResult *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUgraph, CUgraphNode *, CUgraphExecUpdateResult *);
+    ON_ENTRY(cuGraphExecUpdate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[269]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeCopyAttributes(CUgraphNode arg0, CUgraphNode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUgraphNode);
+    ON_ENTRY(cuGraphKernelNodeCopyAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[270]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeGetAttribute(CUgraphNode arg0, CUkernelNodeAttrID arg1, CUkernelNodeAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUkernelNodeAttrID, CUkernelNodeAttrValue *);
+    ON_ENTRY(cuGraphKernelNodeGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[271]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphKernelNodeSetAttribute(CUgraphNode arg0, CUkernelNodeAttrID arg1, const CUkernelNodeAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphNode, CUkernelNodeAttrID, const CUkernelNodeAttrValue *);
+    ON_ENTRY(cuGraphKernelNodeSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[272]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessor(int *arg0, CUfunction arg1, int arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t);
+    ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[273]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *arg0, CUfunction arg1, int arg2, size_t arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUfunction, int, size_t, unsigned int);
+    ON_ENTRY(cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[274]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSize(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int);
+    ON_ENTRY(cuOccupancyMaxPotentialBlockSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[275]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyMaxPotentialBlockSizeWithFlags(int *arg0, int *arg1, CUfunction arg2, CUoccupancyB2DSize arg3, size_t arg4, int arg5, unsigned int arg6) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int);
+    ON_ENTRY(cuOccupancyMaxPotentialBlockSizeWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[276]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+CUresult _WRAPLIB_API_CALL cuOccupancyAvailableDynamicSMemPerBlock(size_t *arg0, CUfunction arg1, int arg2, int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUfunction, int, int);
+    ON_ENTRY(cuOccupancyAvailableDynamicSMemPerBlock);
+    f_ptr_t f = (f_ptr_t)(g_func_table[277]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetArray(CUtexref arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray, unsigned int);
+    ON_ENTRY(cuTexRefSetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[278]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmappedArray(CUtexref arg0, CUmipmappedArray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUmipmappedArray, unsigned int);
+    ON_ENTRY(cuTexRefSetMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[279]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress_v2(size_t *arg0, CUtexref arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(size_t *, CUtexref, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[280]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v3(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress2D_v3);
+    f_ptr_t f = (f_ptr_t)(g_func_table[281]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFormat(CUtexref arg0, CUarray_format arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUarray_format, int);
+    ON_ENTRY(cuTexRefSetFormat);
+    f_ptr_t f = (f_ptr_t)(g_func_table[282]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddressMode(CUtexref arg0, int arg1, CUaddress_mode arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, int, CUaddress_mode);
+    ON_ENTRY(cuTexRefSetAddressMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[283]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFilterMode(CUtexref arg0, CUfilter_mode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
+    ON_ENTRY(cuTexRefSetFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[284]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapFilterMode(CUtexref arg0, CUfilter_mode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, CUfilter_mode);
+    ON_ENTRY(cuTexRefSetMipmapFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[285]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelBias(CUtexref arg0, float arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float);
+    ON_ENTRY(cuTexRefSetMipmapLevelBias);
+    f_ptr_t f = (f_ptr_t)(g_func_table[286]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMipmapLevelClamp(CUtexref arg0, float arg1, float arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float, float);
+    ON_ENTRY(cuTexRefSetMipmapLevelClamp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[287]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetMaxAnisotropy(CUtexref arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
+    ON_ENTRY(cuTexRefSetMaxAnisotropy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[288]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetBorderColor(CUtexref arg0, float *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, float *);
+    ON_ENTRY(cuTexRefSetBorderColor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[289]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetFlags(CUtexref arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, unsigned int);
+    ON_ENTRY(cuTexRefSetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[290]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddress_v2(CUdeviceptr *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUtexref);
+    ON_ENTRY(cuTexRefGetAddress_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[291]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetArray(CUarray *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUtexref);
+    ON_ENTRY(cuTexRefGetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[292]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmappedArray(CUmipmappedArray *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[293]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddressMode(CUaddress_mode *arg0, CUtexref arg1, int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUaddress_mode *, CUtexref, int);
+    ON_ENTRY(cuTexRefGetAddressMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[294]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
+    ON_ENTRY(cuTexRefGetFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[295]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFormat(CUarray_format *arg0, int *arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray_format *, int *, CUtexref);
+    ON_ENTRY(cuTexRefGetFormat);
+    f_ptr_t f = (f_ptr_t)(g_func_table[296]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapFilterMode(CUfilter_mode *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfilter_mode *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapFilterMode);
+    f_ptr_t f = (f_ptr_t)(g_func_table[297]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelBias(float *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapLevelBias);
+    f_ptr_t f = (f_ptr_t)(g_func_table[298]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMipmapLevelClamp(float *arg0, float *arg1, CUtexref arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, float *, CUtexref);
+    ON_ENTRY(cuTexRefGetMipmapLevelClamp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[299]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetMaxAnisotropy(int *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUtexref);
+    ON_ENTRY(cuTexRefGetMaxAnisotropy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[300]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetBorderColor(float *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(float *, CUtexref);
+    ON_ENTRY(cuTexRefGetBorderColor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[301]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetFlags(unsigned int *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref);
+    ON_ENTRY(cuTexRefGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[302]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefCreate(CUtexref *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref *);
+    ON_ENTRY(cuTexRefCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[303]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefDestroy(CUtexref arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref);
+    ON_ENTRY(cuTexRefDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[304]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuSurfRefSetArray(CUsurfref arg0, CUarray arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfref, CUarray, unsigned int);
+    ON_ENTRY(cuSurfRefSetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[305]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuSurfRefGetArray(CUarray *arg0, CUsurfref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUsurfref);
+    ON_ENTRY(cuSurfRefGetArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[306]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectCreate(CUtexObject *arg0, const CUDA_RESOURCE_DESC *arg1, const CUDA_TEXTURE_DESC *arg2, const CUDA_RESOURCE_VIEW_DESC *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject *, const CUDA_RESOURCE_DESC *, const CUDA_TEXTURE_DESC *, const CUDA_RESOURCE_VIEW_DESC *);
+    ON_ENTRY(cuTexObjectCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[307]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectDestroy(CUtexObject arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexObject);
+    ON_ENTRY(cuTexObjectDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[308]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetResourceDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[309]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_TEXTURE_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetTextureDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[310]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *arg0, CUtexObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_VIEW_DESC *, CUtexObject);
+    ON_ENTRY(cuTexObjectGetResourceViewDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[311]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectCreate(CUsurfObject *arg0, const CUDA_RESOURCE_DESC *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject *, const CUDA_RESOURCE_DESC *);
+    ON_ENTRY(cuSurfObjectCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[312]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectDestroy(CUsurfObject arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUsurfObject);
+    ON_ENTRY(cuSurfObjectDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[313]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *arg0, CUsurfObject arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_RESOURCE_DESC *, CUsurfObject);
+    ON_ENTRY(cuSurfObjectGetResourceDesc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[314]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceCanAccessPeer(int *arg0, CUdevice arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceCanAccessPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[315]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxEnablePeerAccess(CUcontext arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext, unsigned int);
+    ON_ENTRY(cuCtxEnablePeerAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[316]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDisablePeerAccess(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDisablePeerAccess);
+    f_ptr_t f = (f_ptr_t)(g_func_table[317]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceGetP2PAttribute(int *arg0, CUdevice_P2PAttribute arg1, CUdevice arg2, CUdevice arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(int *, CUdevice_P2PAttribute, CUdevice, CUdevice);
+    ON_ENTRY(cuDeviceGetP2PAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[318]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnregisterResource(CUgraphicsResource arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource);
+    ON_ENTRY(cuGraphicsUnregisterResource);
+    f_ptr_t f = (f_ptr_t)(g_func_table[319]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsSubResourceGetMappedArray(CUarray *arg0, CUgraphicsResource arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, CUgraphicsResource, unsigned int, unsigned int);
+    ON_ENTRY(cuGraphicsSubResourceGetMappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[320]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *arg0, CUgraphicsResource arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmipmappedArray *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedMipmappedArray);
+    f_ptr_t f = (f_ptr_t)(g_func_table[321]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer_v2(CUdeviceptr *arg0, size_t *arg1, CUgraphicsResource arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedPointer_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[322]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags_v2(CUgraphicsResource arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
+    ON_ENTRY(cuGraphicsResourceSetMapFlags_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[323]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsMapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsMapResources_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[324]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources_ptsz(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsUnmapResources_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[325]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGetExportTable(const void **arg0, const CUuuid *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const void **, const CUuuid *);
+    ON_ENTRY(cuGetExportTable);
+    f_ptr_t f = (f_ptr_t)(g_func_table[326]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuFuncGetModule(CUmodule *arg0, CUfunction arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUmodule *, CUfunction);
+    ON_ENTRY(cuFuncGetModule);
+    f_ptr_t f = (f_ptr_t)(g_func_table[327]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostRegister(void *arg0, size_t arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, unsigned int);
+    ON_ENTRY(cuMemHostRegister);
+    f_ptr_t f = (f_ptr_t)(g_func_table[328]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceSetMapFlags(CUgraphicsResource arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphicsResource, unsigned int);
+    ON_ENTRY(cuGraphicsResourceSetMapFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[329]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuLinkCreate(unsigned int arg0, CUjit_option *arg1, void **arg2, CUlinkState *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUjit_option *, void **, CUlinkState *);
+    ON_ENTRY(cuLinkCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[330]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddData(CUlinkState arg0, CUjitInputType arg1, void *arg2, size_t arg3, const char *arg4, unsigned int arg5, CUjit_option *arg6, void **arg7) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, void *, size_t, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddData);
+    f_ptr_t f = (f_ptr_t)(g_func_table[331]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+CUresult _WRAPLIB_API_CALL cuLinkAddFile(CUlinkState arg0, CUjitInputType arg1, const char *arg2, unsigned int arg3, CUjit_option *arg4, void **arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUlinkState, CUjitInputType, const char *, unsigned int, CUjit_option *, void **);
+    ON_ENTRY(cuLinkAddFile);
+    f_ptr_t f = (f_ptr_t)(g_func_table[332]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D_v2(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR *arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *, CUdeviceptr, size_t);
+    ON_ENTRY(cuTexRefSetAddress2D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[333]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuDeviceTotalMem(unsigned int *arg0, CUdevice arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUdevice);
+    ON_ENTRY(cuDeviceTotalMem);
+    f_ptr_t f = (f_ptr_t)(g_func_table[334]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuCtxCreate(CUcontext *arg0, unsigned int arg1, CUdevice arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *, unsigned int, CUdevice);
+    ON_ENTRY(cuCtxCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[335]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuModuleGetGlobal(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUmodule arg2, const char *arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUmodule, const char *);
+    ON_ENTRY(cuModuleGetGlobal);
+    f_ptr_t f = (f_ptr_t)(g_func_table[336]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetInfo(unsigned int *arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, unsigned int *);
+    ON_ENTRY(cuMemGetInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[337]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAlloc(CUdeviceptr_v1 *arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int);
+    ON_ENTRY(cuMemAlloc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[338]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocPitch(CUdeviceptr_v1 *arg0, unsigned int *arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, unsigned int, unsigned int, unsigned int);
+    ON_ENTRY(cuMemAllocPitch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[339]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemFree(CUdeviceptr_v1 arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1);
+    ON_ENTRY(cuMemFree);
+    f_ptr_t f = (f_ptr_t)(g_func_table[340]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemGetAddressRange(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUdeviceptr_v1 arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUdeviceptr_v1);
+    ON_ENTRY(cuMemGetAddressRange);
+    f_ptr_t f = (f_ptr_t)(g_func_table[341]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocHost(void **arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void **, unsigned int);
+    ON_ENTRY(cuMemAllocHost);
+    f_ptr_t f = (f_ptr_t)(g_func_table[342]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemHostGetDevicePointer(CUdeviceptr_v1 *arg0, void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, void *, unsigned int);
+    ON_ENTRY(cuMemHostGetDevicePointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[343]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int);
+    ON_ENTRY(cuMemcpyHtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[344]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoH);
+    f_ptr_t f = (f_ptr_t)(g_func_table[345]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[346]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA(CUarray arg0, unsigned int arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuMemcpyDtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[347]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD(CUdeviceptr_v1 arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoD);
+    f_ptr_t f = (f_ptr_t)(g_func_table[348]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int);
+    ON_ENTRY(cuMemcpyHtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[349]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoH);
+    f_ptr_t f = (f_ptr_t)(g_func_table[350]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA(CUarray arg0, unsigned int arg1, CUarray arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, CUarray, unsigned int, unsigned int);
+    ON_ENTRY(cuMemcpyAtoA);
+    f_ptr_t f = (f_ptr_t)(g_func_table[351]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync(CUarray arg0, unsigned int arg1, const void *arg2, unsigned int arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, unsigned int, const void *, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[352]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync(void *arg0, CUarray arg1, unsigned int arg2, unsigned int arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, unsigned int, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[353]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D(const CUDA_MEMCPY2D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
+    ON_ENTRY(cuMemcpy2D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[354]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned(const CUDA_MEMCPY2D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *);
+    ON_ENTRY(cuMemcpy2DUnaligned);
+    f_ptr_t f = (f_ptr_t)(g_func_table[355]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D(const CUDA_MEMCPY3D_v1 *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *);
+    ON_ENTRY(cuMemcpy3D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[356]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync(CUdeviceptr_v1 arg0, const void *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, const void *, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[357]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync(void *arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr_v1, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[358]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync(CUdeviceptr_v1 arg0, CUdeviceptr_v1 arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, CUdeviceptr_v1, unsigned int, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[359]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync(const CUDA_MEMCPY2D_v1 *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D_v1 *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[360]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync(const CUDA_MEMCPY3D_v1 *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_v1 *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[361]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8(CUdeviceptr_v1 arg0, unsigned char arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned char, unsigned int);
+    ON_ENTRY(cuMemsetD8);
+    f_ptr_t f = (f_ptr_t)(g_func_table[362]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16(CUdeviceptr_v1 arg0, unsigned short arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned short, unsigned int);
+    ON_ENTRY(cuMemsetD16);
+    f_ptr_t f = (f_ptr_t)(g_func_table[363]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[364]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned char arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned char, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D8);
+    f_ptr_t f = (f_ptr_t)(g_func_table[365]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned short arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned short, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D16);
+    f_ptr_t f = (f_ptr_t)(g_func_table[366]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32(CUdeviceptr_v1 arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1, unsigned int, unsigned int, unsigned int, unsigned int);
+    ON_ENTRY(cuMemsetD2D32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[367]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuArrayCreate(CUarray *arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY_DESCRIPTOR_v1 *);
+    ON_ENTRY(cuArrayCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[368]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY_DESCRIPTOR_v1 *, CUarray);
+    ON_ENTRY(cuArrayGetDescriptor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[369]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DCreate(CUarray *arg0, const CUDA_ARRAY3D_DESCRIPTOR_v1 *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR_v1 *);
+    ON_ENTRY(cuArray3DCreate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[370]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR_v1 *arg0, CUarray arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUDA_ARRAY3D_DESCRIPTOR_v1 *, CUarray);
+    ON_ENTRY(cuArray3DGetDescriptor);
+    f_ptr_t f = (f_ptr_t)(g_func_table[371]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress(unsigned int *arg0, CUtexref arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int *, CUtexref, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuTexRefSetAddress);
+    f_ptr_t f = (f_ptr_t)(g_func_table[372]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefSetAddress2D(CUtexref arg0, const CUDA_ARRAY_DESCRIPTOR_v1 *arg1, CUdeviceptr_v1 arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUtexref, const CUDA_ARRAY_DESCRIPTOR_v1 *, CUdeviceptr_v1, unsigned int);
+    ON_ENTRY(cuTexRefSetAddress2D);
+    f_ptr_t f = (f_ptr_t)(g_func_table[373]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuTexRefGetAddress(CUdeviceptr_v1 *arg0, CUtexref arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, CUtexref);
+    ON_ENTRY(cuTexRefGetAddress);
+    f_ptr_t f = (f_ptr_t)(g_func_table[374]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsResourceGetMappedPointer(CUdeviceptr_v1 *arg0, unsigned int *arg1, CUgraphicsResource arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr_v1 *, unsigned int *, CUgraphicsResource);
+    ON_ENTRY(cuGraphicsResourceGetMappedPointer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[375]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuCtxDestroy(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[376]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPopCurrent(CUcontext *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext *);
+    ON_ENTRY(cuCtxPopCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[377]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuCtxPushCurrent(CUcontext arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUcontext);
+    ON_ENTRY(cuCtxPushCurrent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[378]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamDestroy(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[379]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventDestroy(CUevent arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent);
+    ON_ENTRY(cuEventDestroy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[380]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxRelease(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxRelease);
+    f_ptr_t f = (f_ptr_t)(g_func_table[381]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxReset(CUdevice arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice);
+    ON_ENTRY(cuDevicePrimaryCtxReset);
+    f_ptr_t f = (f_ptr_t)(g_func_table[382]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuDevicePrimaryCtxSetFlags(CUdevice arg0, unsigned int arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdevice, unsigned int);
+    ON_ENTRY(cuDevicePrimaryCtxSetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[383]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoD_v2(CUdeviceptr arg0, const void *arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[384]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoH_v2(void *arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoH_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[385]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoD_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[386]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoA_v2(CUarray arg0, size_t arg1, CUdeviceptr arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpyDtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[387]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoD_v2(CUdeviceptr arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoD_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[388]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoA_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t);
+    ON_ENTRY(cuMemcpyHtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[389]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoH_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoH_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[390]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoA_v2(CUarray arg0, size_t arg1, CUarray arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, CUarray, size_t, size_t);
+    ON_ENTRY(cuMemcpyAtoA_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[391]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoAAsync_v2(CUarray arg0, size_t arg1, const void *arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarray, size_t, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoAAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[392]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAtoHAsync_v2(void *arg0, CUarray arg1, size_t arg2, size_t arg3, CUstream arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUarray, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAtoHAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[393]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2D_v2(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[394]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *);
+    ON_ENTRY(cuMemcpy2DUnaligned_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[395]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3D_v2(const CUDA_MEMCPY3D *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *);
+    ON_ENTRY(cuMemcpy3D_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[396]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyHtoDAsync_v2(CUdeviceptr arg0, const void *arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, const void *, size_t, CUstream);
+    ON_ENTRY(cuMemcpyHtoDAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[397]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoHAsync_v2(void *arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(void *, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoHAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[398]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyDtoDAsync_v2(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyDtoDAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[399]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY2D *, CUstream);
+    ON_ENTRY(cuMemcpy2DAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[400]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D *, CUstream);
+    ON_ENTRY(cuMemcpy3DAsync_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[401]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8_v2(CUdeviceptr arg0, unsigned char arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t);
+    ON_ENTRY(cuMemsetD8_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[402]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16_v2(CUdeviceptr arg0, unsigned short arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t);
+    ON_ENTRY(cuMemsetD16_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[403]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32_v2(CUdeviceptr arg0, unsigned int arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t);
+    ON_ENTRY(cuMemsetD32_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[404]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8_v2(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D8_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[405]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16_v2(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D16_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[406]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32_v2(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
+    ON_ENTRY(cuMemsetD2D32_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[407]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t);
+    ON_ENTRY(cuMemcpy);
+    f_ptr_t f = (f_ptr_t)(g_func_table[408]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyAsync(CUdeviceptr arg0, CUdeviceptr arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
+    ON_ENTRY(cuMemcpyAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[409]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeer(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t);
+    ON_ENTRY(cuMemcpyPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[410]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpyPeerAsync(CUdeviceptr arg0, CUcontext arg1, CUdeviceptr arg2, CUcontext arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream);
+    ON_ENTRY(cuMemcpyPeerAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[411]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *);
+    ON_ENTRY(cuMemcpy3DPeer);
+    f_ptr_t f = (f_ptr_t)(g_func_table[412]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUDA_MEMCPY3D_PEER *, CUstream);
+    ON_ENTRY(cuMemcpy3DPeerAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[413]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD8Async(CUdeviceptr arg0, unsigned char arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned char, size_t, CUstream);
+    ON_ENTRY(cuMemsetD8Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[414]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD16Async(CUdeviceptr arg0, unsigned short arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned short, size_t, CUstream);
+    ON_ENTRY(cuMemsetD16Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[415]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD32Async(CUdeviceptr arg0, unsigned int arg1, size_t arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, unsigned int, size_t, CUstream);
+    ON_ENTRY(cuMemsetD32Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[416]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D8Async(CUdeviceptr arg0, size_t arg1, unsigned char arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D8Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[417]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D16Async(CUdeviceptr arg0, size_t arg1, unsigned short arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D16Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[418]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuMemsetD2D32Async(CUdeviceptr arg0, size_t arg1, unsigned int arg2, size_t arg3, size_t arg4, CUstream arg5) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream);
+    ON_ENTRY(cuMemsetD2D32Async);
+    f_ptr_t f = (f_ptr_t)(g_func_table[419]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetPriority(CUstream arg0, int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, int *);
+    ON_ENTRY(cuStreamGetPriority);
+    f_ptr_t f = (f_ptr_t)(g_func_table[420]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetFlags(CUstream arg0, unsigned int *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int *);
+    ON_ENTRY(cuStreamGetFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[421]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCtx(CUstream arg0, CUcontext *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUcontext *);
+    ON_ENTRY(cuStreamGetCtx);
+    f_ptr_t f = (f_ptr_t)(g_func_table[422]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitEvent(CUstream arg0, CUevent arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUevent, unsigned int);
+    ON_ENTRY(cuStreamWaitEvent);
+    f_ptr_t f = (f_ptr_t)(g_func_table[423]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAddCallback(CUstream arg0, CUstreamCallback arg1, void *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCallback, void *, unsigned int);
+    ON_ENTRY(cuStreamAddCallback);
+    f_ptr_t f = (f_ptr_t)(g_func_table[424]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamAttachMemAsync(CUstream arg0, CUdeviceptr arg1, size_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, size_t, unsigned int);
+    ON_ENTRY(cuStreamAttachMemAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[425]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamQuery(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamQuery);
+    f_ptr_t f = (f_ptr_t)(g_func_table[426]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSynchronize(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamSynchronize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[427]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecord(CUevent arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream);
+    ON_ENTRY(cuEventRecord);
+    f_ptr_t f = (f_ptr_t)(g_func_table[428]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuEventRecordWithFlags(CUevent arg0, CUstream arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUevent, CUstream, unsigned int);
+    ON_ENTRY(cuEventRecordWithFlags);
+    f_ptr_t f = (f_ptr_t)(g_func_table[429]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9, void **arg10) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
+    ON_ENTRY(cuLaunchKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[430]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchHostFunc(CUstream arg0, CUhostFn arg1, void *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUhostFn, void *);
+    ON_ENTRY(cuLaunchHostFunc);
+    f_ptr_t f = (f_ptr_t)(g_func_table[431]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsMapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsMapResources);
+    f_ptr_t f = (f_ptr_t)(g_func_table[432]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphicsUnmapResources(unsigned int arg0, CUgraphicsResource *arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(unsigned int, CUgraphicsResource *, CUstream);
+    ON_ENTRY(cuGraphicsUnmapResources);
+    f_ptr_t f = (f_ptr_t)(g_func_table[433]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[434]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue32(CUstream arg0, CUdeviceptr arg1, cuuint32_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue32);
+    f_ptr_t f = (f_ptr_t)(g_func_table[435]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWriteValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWriteValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[436]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamWaitValue64(CUstream arg0, CUdeviceptr arg1, cuuint64_t arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
+    ON_ENTRY(cuStreamWaitValue64);
+    f_ptr_t f = (f_ptr_t)(g_func_table[437]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBatchMemOp(CUstream arg0, unsigned int arg1, CUstreamBatchMemOpParams *arg2, unsigned int arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, unsigned int, CUstreamBatchMemOpParams *, unsigned int);
+    ON_ENTRY(cuStreamBatchMemOp);
+    f_ptr_t f = (f_ptr_t)(g_func_table[438]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuMemPrefetchAsync(CUdeviceptr arg0, size_t arg1, CUdevice arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, size_t, CUdevice, CUstream);
+    ON_ENTRY(cuMemPrefetchAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[439]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuLaunchCooperativeKernel(CUfunction arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3, unsigned int arg4, unsigned int arg5, unsigned int arg6, unsigned int arg7, CUstream arg8, void **arg9) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void **);
+    ON_ENTRY(cuLaunchCooperativeKernel);
+    f_ptr_t f = (f_ptr_t)(g_func_table[440]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+CUresult _WRAPLIB_API_CALL cuSignalExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuSignalExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[441]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuWaitExternalSemaphoresAsync(const CUexternalSemaphore *arg0, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *arg1, unsigned int arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *, unsigned int, CUstream);
+    ON_ENTRY(cuWaitExternalSemaphoresAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[442]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[443]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_ptsz(CUstream arg0) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream);
+    ON_ENTRY(cuStreamBeginCapture_ptsz);
+    f_ptr_t f = (f_ptr_t)(g_func_table[444]);
+    return f(arg0);
+}
+CUresult _WRAPLIB_API_CALL cuStreamBeginCapture_v2(CUstream arg0, CUstreamCaptureMode arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureMode);
+    ON_ENTRY(cuStreamBeginCapture_v2);
+    f_ptr_t f = (f_ptr_t)(g_func_table[445]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamEndCapture(CUstream arg0, CUgraph *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUgraph *);
+    ON_ENTRY(cuStreamEndCapture);
+    f_ptr_t f = (f_ptr_t)(g_func_table[446]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamIsCapturing(CUstream arg0, CUstreamCaptureStatus *arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *);
+    ON_ENTRY(cuStreamIsCapturing);
+    f_ptr_t f = (f_ptr_t)(g_func_table[447]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetCaptureInfo(CUstream arg0, CUstreamCaptureStatus *arg1, cuuint64_t *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamCaptureStatus *, cuuint64_t *);
+    ON_ENTRY(cuStreamGetCaptureInfo);
+    f_ptr_t f = (f_ptr_t)(g_func_table[448]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphUpload(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphUpload);
+    f_ptr_t f = (f_ptr_t)(g_func_table[449]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuGraphLaunch(CUgraphExec arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec, CUstream);
+    ON_ENTRY(cuGraphLaunch);
+    f_ptr_t f = (f_ptr_t)(g_func_table[450]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamCopyAttributes(CUstream arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstream);
+    ON_ENTRY(cuStreamCopyAttributes);
+    f_ptr_t f = (f_ptr_t)(g_func_table[451]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuStreamGetAttribute(CUstream arg0, CUstreamAttrID arg1, CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, CUstreamAttrValue *);
+    ON_ENTRY(cuStreamGetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[452]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuStreamSetAttribute(CUstream arg0, CUstreamAttrID arg1, const CUstreamAttrValue *arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUstream, CUstreamAttrID, const CUstreamAttrValue *);
+    ON_ENTRY(cuStreamSetAttribute);
+    f_ptr_t f = (f_ptr_t)(g_func_table[453]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuIpcOpenMemHandle(CUdeviceptr *arg0, CUipcMemHandle arg1, unsigned int arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, CUipcMemHandle, unsigned int);
+    ON_ENTRY(cuIpcOpenMemHandle);
+    f_ptr_t f = (f_ptr_t)(g_func_table[454]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuGraphInstantiate(CUgraphExec *arg0, CUgraph arg1, CUgraphNode *arg2, char *arg3, size_t arg4) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUgraphExec *, CUgraph, CUgraphNode *, char *, size_t);
+    ON_ENTRY(cuGraphInstantiate);
+    f_ptr_t f = (f_ptr_t)(g_func_table[455]);
+    return f(arg0, arg1, arg2, arg3, arg4);
+}
+CUresult _WRAPLIB_API_CALL cuMemMapArrayAsync(CUarrayMapInfo *arg0, unsigned int arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUarrayMapInfo *, unsigned int, CUstream);
+    ON_ENTRY(cuMemMapArrayAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[456]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemFreeAsync(CUdeviceptr arg0, CUstream arg1) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr, CUstream);
+    ON_ENTRY(cuMemFreeAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[457]);
+    return f(arg0, arg1);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocAsync(CUdeviceptr *arg0, size_t arg1, CUstream arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, CUstream);
+    ON_ENTRY(cuMemAllocAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[458]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuMemAllocFromPoolAsync(CUdeviceptr *arg0, size_t arg1, CUmemoryPool arg2, CUstream arg3) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(CUdeviceptr *, size_t, CUmemoryPool, CUstream);
+    ON_ENTRY(cuMemAllocFromPoolAsync);
+    f_ptr_t f = (f_ptr_t)(g_func_table[459]);
+    return f(arg0, arg1, arg2, arg3);
+}
+CUresult _WRAPLIB_API_CALL cuProfilerInitialize(const char *arg0, const char *arg1, CUoutput_mode arg2) {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)(const char *, const char *, CUoutput_mode);
+    ON_ENTRY(cuProfilerInitialize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[460]);
+    return f(arg0, arg1, arg2);
+}
+CUresult _WRAPLIB_API_CALL cuProfilerStart() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuProfilerStart);
+    f_ptr_t f = (f_ptr_t)(g_func_table[461]);
+    return f();
+}
+CUresult _WRAPLIB_API_CALL cuProfilerStop() {
+    typedef CUresult (_WRAPLIB_API_CALL *f_ptr_t)();
+    ON_ENTRY(cuProfilerStop);
+    f_ptr_t f = (f_ptr_t)(g_func_table[462]);
+    return f();
+}
diff --git a/dnn/cuda-stub/src/libcuda.cpp b/dnn/cuda-stub/src/libcuda.cpp
index 50f25c007419226a65ef6a162b2655ae3de4528c..0a20aba51dd2bdcd9876aa12972ebccdd589ed27 100644
--- a/dnn/cuda-stub/src/libcuda.cpp
+++ b/dnn/cuda-stub/src/libcuda.cpp
@@ -3,36 +3,14 @@
 #include <cstdio>
 #define LOGE(fmt, v...) fprintf(stderr, "err: " fmt "\n", ##v)
 
+
 extern "C" {
-#include <cuda.h>
+#include "cuda.h"
 }
-#include <cudaProfiler.h>
+#include "cudaProfiler.h"
 
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
-#if defined(_WIN32)
-#include <windows.h>
-#define RTLD_LAZY 0
-
-static void* dlopen(const char* file, int) {
-    return static_cast<void*>(LoadLibraryA(file));
-}
-
-static void* dlerror() {
-    const char* errmsg = "dlerror not aviable in windows";
-    return const_cast<char*>(errmsg);
-}
-
-static void* dlsym(void* handle, const char* name) {
-    FARPROC symbol = GetProcAddress((HMODULE)handle, name);
-    return reinterpret_cast<void*>(symbol);
-}
-
-#else
-#include <dlfcn.h>
-#include <unistd.h>
-#endif
-
 static void log_failed_load(int func_idx);
 namespace {
 template <typename T>
@@ -42,68 +20,63 @@ CUresult on_init_failed(int func_idx) {
     log_failed_load(func_idx);
     return CUDA_ERROR_UNKNOWN;
 }
-}
+
+}  // namespace
 
 #define _WRAPLIB_API_CALL CUDAAPI
 #define _WRAPLIB_CALLBACK CUDA_CB
-#include "./libcuda-wrap.h"
+
+#if CUDA_VERSION == 10010
+#include "./libcuda-wrap_10.1.h"
+#elif CUDA_VERSION == 10020
+#include "./libcuda-wrap_10.2.h"
+#elif CUDA_VERSION == 11010
+#include "./libcuda-wrap_11.1.h"
+#elif CUDA_VERSION == 11020
+#include "./libcuda-wrap_11.2.h"
+#else
+#error "cuda stub not support this cuda version, you can close cuda stub to passby"
+#endif
+
+
 #undef _WRAPLIB_CALLBACK
 #undef _WRAPLIB_API_CALL
 
+static const char* default_so_name =
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+        "nvcuda.dll";
+#elif defined(__APPLE__) || defined(__MACOSX)
+        "libcuda.dylib";
+#else
+        "libcuda.so.1";
+#endif
+
 // Harvested from cuda_drvapi_dynlink.c
 static const char* default_so_paths[] = {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
-    "nvcuda.dll",
-#elif defined(__unix__) || defined (__QNX__) || defined(__APPLE__) || defined(__MACOSX)
+        "nvcuda.dll",
+#elif defined(__unix__) || defined(__QNX__) || defined(__APPLE__) || \
+        defined(__MACOSX)
 #if defined(__APPLE__) || defined(__MACOSX)
-    "/usr/local/cuda/lib/libcuda.dylib",
+        "/usr/local/cuda/lib/libcuda.dylib",
 #elif defined(__ANDROID__)
-#if defined (__aarch64__)
-    "/system/vendor/lib64/libcuda.so",
+#if defined(__aarch64__)
+        "/system/vendor/lib64/libcuda.so",
 #elif defined(__arm__)
-    "/system/vendor/lib/libcuda.so",
+        "/system/vendor/lib/libcuda.so",
 #endif
 #else
-    "libcuda.so.1",
-    
-    // In case some users does not have correct search path configured in
-    // /etc/ld.so.conf
-    "/usr/lib/x86_64-linux-gnu/libcuda.so",
-    "/usr/local/nvidia/lib64/libcuda.so",
+        "libcuda.so.1",
 #endif
 #else
 #error "Unknown platform"
 #endif
 };
 
-static void* get_library_handle() {
-    void* handle = nullptr;
-    for (size_t i = 0; i < (sizeof(default_so_paths) / sizeof(char*)); i++) {
-        handle = dlopen(default_so_paths[i], RTLD_LAZY);
-        if (handle) {
-            break;
-        }
-    }
-
-    if (!handle) {
-        LOGE("Failed to load CUDA Driver API library");
-        return nullptr;
-    }
-    return handle;
-}
-
-static void log_failed_load(int func_idx) {
-    LOGE("failed to load cuda func: %s", g_func_name[func_idx]);
-}
+static const char* extra_so_paths[] = {
+        "/usr/lib/x86_64-linux-gnu/libcuda.so",
+        "/usr/local/nvidia/lib64/libcuda.so",
+};
 
-static void* resolve_library_func(void* handle, const char* func) {
-    if (!handle) {
-        LOGE("handle should not be nullptr!");
-        return nullptr;
-    }
-    auto ret = dlsym(handle, func);
-    if (!ret) {
-        LOGE("failed to load cuda func: %s", func);
-    }
-    return ret;
-}
+static const char* g_default_api_name = "cuda";
+#include "./dlopen_helper.h"
\ No newline at end of file
diff --git a/dnn/cuda-stub/src/libnvrtc-wrap.h b/dnn/cuda-stub/src/libnvrtc-wrap.h
new file mode 100644
index 0000000000000000000000000000000000000000..95011f05d14c29fd6d7017b3f9f7257c2f7e5a9c
--- /dev/null
+++ b/dnn/cuda-stub/src/libnvrtc-wrap.h
@@ -0,0 +1,367 @@
+// generated by wraplib.py
+// --- begin functions to be implemented
+#ifndef _WRAPLIB_API_CALL
+#define _WRAPLIB_API_CALL
+#endif
+#ifndef _WRAPLIB_CALLBACK
+#define _WRAPLIB_CALLBACK
+#endif
+#ifndef ON_ENTRY
+#define ON_ENTRY(x)
+#endif
+static void* get_library_handle();
+static void* resolve_library_func(void*, const char*);
+namespace {
+template <typename T>
+T on_init_failed(int func_idx);
+}
+// --- end functions to be implemented
+#include <cstddef>
+#include <mutex>
+extern "C" {
+const char _WRAPLIB_API_CALL* nvrtcGetErrorString(nvrtcResult arg0);
+nvrtcResult _WRAPLIB_API_CALL nvrtcVersion(int* arg0, int* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetNumSupportedArchs(int* arg0);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetSupportedArchs(int* arg0);
+nvrtcResult _WRAPLIB_API_CALL nvrtcCreateProgram(nvrtcProgram* arg0,
+                                                 const char* arg1,
+                                                 const char* arg2, int arg3,
+                                                 const char* const* arg4,
+                                                 const char* const* arg5);
+nvrtcResult _WRAPLIB_API_CALL nvrtcDestroyProgram(nvrtcProgram* arg0);
+nvrtcResult _WRAPLIB_API_CALL nvrtcCompileProgram(nvrtcProgram arg0, int arg1,
+                                                  const char* const* arg2);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTXSize(nvrtcProgram arg0, size_t* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTX(nvrtcProgram arg0, char* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBINSize(nvrtcProgram arg0,
+                                                size_t* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBIN(nvrtcProgram arg0, char* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLogSize(nvrtcProgram arg0,
+                                                     size_t* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLog(nvrtcProgram arg0, char* arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcAddNameExpression(nvrtcProgram arg0,
+                                                     const char* const arg1);
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetLoweredName(nvrtcProgram arg0,
+                                                  const char* const arg1,
+                                                  const char** arg2);
+}
+static void load_library();
+static const char _WRAPLIB_API_CALL* nvrtcGetErrorString_init(
+        nvrtcResult arg0) {
+    load_library();
+    return nvrtcGetErrorString(arg0);
+}
+static const char _WRAPLIB_API_CALL* nvrtcGetErrorString_error(nvrtcResult) {
+    return on_init_failed<const char*>(0);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcVersion_init(int* arg0, int* arg1) {
+    load_library();
+    return nvrtcVersion(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcVersion_error(int*, int*) {
+    return on_init_failed<nvrtcResult>(1);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetNumSupportedArchs_init(int* arg0) {
+    load_library();
+    return nvrtcGetNumSupportedArchs(arg0);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetNumSupportedArchs_error(int*) {
+    return on_init_failed<nvrtcResult>(2);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetSupportedArchs_init(int* arg0) {
+    load_library();
+    return nvrtcGetSupportedArchs(arg0);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetSupportedArchs_error(int*) {
+    return on_init_failed<nvrtcResult>(3);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcCreateProgram_init(
+        nvrtcProgram* arg0, const char* arg1, const char* arg2, int arg3,
+        const char* const* arg4, const char* const* arg5) {
+    load_library();
+    return nvrtcCreateProgram(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcCreateProgram_error(nvrtcProgram*, const char*, const char*, int,
+                         const char* const*, const char* const*) {
+    return on_init_failed<nvrtcResult>(4);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcDestroyProgram_init(nvrtcProgram* arg0) {
+    load_library();
+    return nvrtcDestroyProgram(arg0);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcDestroyProgram_error(nvrtcProgram*) {
+    return on_init_failed<nvrtcResult>(5);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcCompileProgram_init(nvrtcProgram arg0, int arg1, const char* const* arg2) {
+    load_library();
+    return nvrtcCompileProgram(arg0, arg1, arg2);
+}
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcCompileProgram_error(nvrtcProgram, int, const char* const*) {
+    return on_init_failed<nvrtcResult>(6);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTXSize_init(nvrtcProgram arg0,
+                                                          size_t* arg1) {
+    load_library();
+    return nvrtcGetPTXSize(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTXSize_error(nvrtcProgram,
+                                                           size_t*) {
+    return on_init_failed<nvrtcResult>(7);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTX_init(nvrtcProgram arg0,
+                                                      char* arg1) {
+    load_library();
+    return nvrtcGetPTX(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTX_error(nvrtcProgram, char*) {
+    return on_init_failed<nvrtcResult>(8);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBINSize_init(nvrtcProgram arg0,
+                                                            size_t* arg1) {
+    load_library();
+    return nvrtcGetCUBINSize(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBINSize_error(nvrtcProgram,
+                                                             size_t*) {
+    return on_init_failed<nvrtcResult>(9);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBIN_init(nvrtcProgram arg0,
+                                                        char* arg1) {
+    load_library();
+    return nvrtcGetCUBIN(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBIN_error(nvrtcProgram, char*) {
+    return on_init_failed<nvrtcResult>(10);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcGetProgramLogSize_init(nvrtcProgram arg0, size_t* arg1) {
+    load_library();
+    return nvrtcGetProgramLogSize(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLogSize_error(nvrtcProgram,
+                                                                  size_t*) {
+    return on_init_failed<nvrtcResult>(11);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLog_init(nvrtcProgram arg0,
+                                                             char* arg1) {
+    load_library();
+    return nvrtcGetProgramLog(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLog_error(nvrtcProgram,
+                                                              char*) {
+    return on_init_failed<nvrtcResult>(12);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcAddNameExpression_init(nvrtcProgram arg0, const char* const arg1) {
+    load_library();
+    return nvrtcAddNameExpression(arg0, arg1);
+}
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcAddNameExpression_error(nvrtcProgram, const char* const) {
+    return on_init_failed<nvrtcResult>(13);
+}
+
+static nvrtcResult _WRAPLIB_API_CALL nvrtcGetLoweredName_init(
+        nvrtcProgram arg0, const char* const arg1, const char** arg2) {
+    load_library();
+    return nvrtcGetLoweredName(arg0, arg1, arg2);
+}
+static nvrtcResult _WRAPLIB_API_CALL
+nvrtcGetLoweredName_error(nvrtcProgram, const char* const, const char**) {
+    return on_init_failed<nvrtcResult>(14);
+}
+static constexpr size_t NR_FUNC = 15;
+static void* g_func_table[NR_FUNC] = {(void*)(&nvrtcGetErrorString_init),
+                                      (void*)(&nvrtcVersion_init),
+                                      (void*)(&nvrtcGetNumSupportedArchs_init),
+                                      (void*)(&nvrtcGetSupportedArchs_init),
+                                      (void*)(&nvrtcCreateProgram_init),
+                                      (void*)(&nvrtcDestroyProgram_init),
+                                      (void*)(&nvrtcCompileProgram_init),
+                                      (void*)(&nvrtcGetPTXSize_init),
+                                      (void*)(&nvrtcGetPTX_init),
+                                      (void*)(&nvrtcGetCUBINSize_init),
+                                      (void*)(&nvrtcGetCUBIN_init),
+                                      (void*)(&nvrtcGetProgramLogSize_init),
+                                      (void*)(&nvrtcGetProgramLog_init),
+                                      (void*)(&nvrtcAddNameExpression_init),
+                                      (void*)(&nvrtcGetLoweredName_init)};
+static void* g_func_table_error[NR_FUNC] = {
+        (void*)(&nvrtcGetErrorString_error),
+        (void*)(&nvrtcVersion_error),
+        (void*)(&nvrtcGetNumSupportedArchs_error),
+        (void*)(&nvrtcGetSupportedArchs_error),
+        (void*)(&nvrtcCreateProgram_error),
+        (void*)(&nvrtcDestroyProgram_error),
+        (void*)(&nvrtcCompileProgram_error),
+        (void*)(&nvrtcGetPTXSize_error),
+        (void*)(&nvrtcGetPTX_error),
+        (void*)(&nvrtcGetCUBINSize_error),
+        (void*)(&nvrtcGetCUBIN_error),
+        (void*)(&nvrtcGetProgramLogSize_error),
+        (void*)(&nvrtcGetProgramLog_error),
+        (void*)(&nvrtcAddNameExpression_error),
+        (void*)(&nvrtcGetLoweredName_error)};
+static const char* const g_func_name[NR_FUNC] = {"nvrtcGetErrorString",
+                                                 "nvrtcVersion",
+                                                 "nvrtcGetNumSupportedArchs",
+                                                 "nvrtcGetSupportedArchs",
+                                                 "nvrtcCreateProgram",
+                                                 "nvrtcDestroyProgram",
+                                                 "nvrtcCompileProgram",
+                                                 "nvrtcGetPTXSize",
+                                                 "nvrtcGetPTX",
+                                                 "nvrtcGetCUBINSize",
+                                                 "nvrtcGetCUBIN",
+                                                 "nvrtcGetProgramLogSize",
+                                                 "nvrtcGetProgramLog",
+                                                 "nvrtcAddNameExpression",
+                                                 "nvrtcGetLoweredName"};
+
+static void load_library() {
+    static bool done = false;
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lg{mtx};
+
+    if (done)
+        return;
+
+    void* handle = get_library_handle();
+    for (size_t i = 0; i < NR_FUNC; ++i) {
+        void* func;
+        if (!handle) {
+            func = nullptr;
+        } else {
+            func = resolve_library_func(handle, g_func_name[i]);
+        }
+        if (!func) {
+            func = g_func_table_error[i];
+        }
+        __atomic_store_n(g_func_table + i, func, __ATOMIC_RELAXED);
+    }
+    done = true;
+}
+
+const char _WRAPLIB_API_CALL* nvrtcGetErrorString(nvrtcResult arg0) {
+    typedef const char*(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcResult);
+    ON_ENTRY(nvrtcGetErrorString);
+    f_ptr_t f = (f_ptr_t)(g_func_table[0]);
+    return f(arg0);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcVersion(int* arg0, int* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(int*, int*);
+    ON_ENTRY(nvrtcVersion);
+    f_ptr_t f = (f_ptr_t)(g_func_table[1]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetNumSupportedArchs(int* arg0) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(int*);
+    ON_ENTRY(nvrtcGetNumSupportedArchs);
+    f_ptr_t f = (f_ptr_t)(g_func_table[2]);
+    return f(arg0);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetSupportedArchs(int* arg0) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(int*);
+    ON_ENTRY(nvrtcGetSupportedArchs);
+    f_ptr_t f = (f_ptr_t)(g_func_table[3]);
+    return f(arg0);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcCreateProgram(nvrtcProgram* arg0,
+                                                 const char* arg1,
+                                                 const char* arg2, int arg3,
+                                                 const char* const* arg4,
+                                                 const char* const* arg5) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(
+            nvrtcProgram*, const char*, const char*, int, const char* const*,
+            const char* const*);
+    ON_ENTRY(nvrtcCreateProgram);
+    f_ptr_t f = (f_ptr_t)(g_func_table[4]);
+    return f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcDestroyProgram(nvrtcProgram* arg0) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram*);
+    ON_ENTRY(nvrtcDestroyProgram);
+    f_ptr_t f = (f_ptr_t)(g_func_table[5]);
+    return f(arg0);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcCompileProgram(nvrtcProgram arg0, int arg1,
+                                                  const char* const* arg2) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, int,
+                                                     const char* const*);
+    ON_ENTRY(nvrtcCompileProgram);
+    f_ptr_t f = (f_ptr_t)(g_func_table[6]);
+    return f(arg0, arg1, arg2);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTXSize(nvrtcProgram arg0, size_t* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, size_t*);
+    ON_ENTRY(nvrtcGetPTXSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetPTX(nvrtcProgram arg0, char* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, char*);
+    ON_ENTRY(nvrtcGetPTX);
+    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBINSize(nvrtcProgram arg0,
+                                                size_t* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, size_t*);
+    ON_ENTRY(nvrtcGetCUBINSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetCUBIN(nvrtcProgram arg0, char* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, char*);
+    ON_ENTRY(nvrtcGetCUBIN);
+    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLogSize(nvrtcProgram arg0,
+                                                     size_t* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, size_t*);
+    ON_ENTRY(nvrtcGetProgramLogSize);
+    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetProgramLog(nvrtcProgram arg0,
+                                                 char* arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram, char*);
+    ON_ENTRY(nvrtcGetProgramLog);
+    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcAddNameExpression(nvrtcProgram arg0,
+                                                     const char* const arg1) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(nvrtcProgram,
+                                                     const char* const);
+    ON_ENTRY(nvrtcAddNameExpression);
+    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
+    return f(arg0, arg1);
+}
+nvrtcResult _WRAPLIB_API_CALL nvrtcGetLoweredName(nvrtcProgram arg0,
+                                                  const char* const arg1,
+                                                  const char** arg2) {
+    typedef nvrtcResult(_WRAPLIB_API_CALL * f_ptr_t)(
+            nvrtcProgram, const char* const, const char**);
+    ON_ENTRY(nvrtcGetLoweredName);
+    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
+    return f(arg0, arg1, arg2);
+}
diff --git a/dnn/cuda-stub/src/libnvrtc.cpp b/dnn/cuda-stub/src/libnvrtc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..03522026ddeba59f2fdb1be12438ce6a6a9bd249
--- /dev/null
+++ b/dnn/cuda-stub/src/libnvrtc.cpp
@@ -0,0 +1,75 @@
+/**
+ * \file dnn/cuda-stub/src/libnvrtc.cpp
+ * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
+ *
+ * Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied.
+ */
+
+#pragma GCC visibility push(default)
+
+#include <cstdio>
+#define LOGE(fmt, v...) fprintf(stderr, "err: " fmt "\n", ##v)
+#include "./nvrtc_type.h"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+static void log_failed_load(int func_idx);
+namespace {
+template <typename T>
+T on_init_failed(int func_idx);
+template <>
+nvrtcResult on_init_failed(int func_idx) {
+    log_failed_load(func_idx);
+    return NVRTC_ERROR_INTERNAL_ERROR;
+}
+template <>
+const char* on_init_failed(int func_idx) {
+    log_failed_load(func_idx);
+    return "load lib failed";
+}
+}  // namespace
+
+#include "./libnvrtc-wrap.h"
+static const char* default_so_name =
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+        "nvrtc.dll";
+#elif defined(__APPLE__) || defined(__MACOSX)
+        "libnvrtc.dylib";
+#else
+        "libnvrtc.so";
+#endif
+
+static const char* default_so_paths[] = {
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+        "nvrtc.dll",
+#elif defined(__unix__) || defined(__QNX__) || defined(__APPLE__) || \
+        defined(__MACOSX)
+#if defined(__APPLE__) || defined(__MACOSX)
+        "/usr/local/cuda/lib/libnvrtc.dylib",
+#elif defined(__ANDROID__)
+#if defined(__aarch64__)
+        "/system/vendor/lib64/libnvrtc.so",
+#elif defined(__arm__)
+        "/system/vendor/lib/libnvrtc.so",
+#endif
+#else
+        "libnvrtc.so",
+
+        // In case some users does not have correct search path configured in
+        // /etc/ld.so.conf
+        "/usr/lib/x86_64-linux-gnu/libnvrtc.so",
+        "/usr/local/nvidia/lib64/libnvrtc.so",
+        "/usr/local/cuda/lib64/libnvrtc.so",
+#endif
+#else
+#error "Unknown platform"
+#endif
+};
+static const char* extra_so_paths[] = {};
+
+static const char* g_default_api_name = "nvrtc";
+#include "./dlopen_helper.h"
\ No newline at end of file
diff --git a/dnn/cuda-stub/src/nvrtc_type.h b/dnn/cuda-stub/src/nvrtc_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..f1c83c1347d0dd95f01f8a8dbc5dccaa8a8d2e51
--- /dev/null
+++ b/dnn/cuda-stub/src/nvrtc_type.h
@@ -0,0 +1,27 @@
+#pragma once
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <stdlib.h>
+
+typedef enum {
+  NVRTC_SUCCESS = 0,
+  NVRTC_ERROR_OUT_OF_MEMORY = 1,
+  NVRTC_ERROR_PROGRAM_CREATION_FAILURE = 2,
+  NVRTC_ERROR_INVALID_INPUT = 3,
+  NVRTC_ERROR_INVALID_PROGRAM = 4,
+  NVRTC_ERROR_INVALID_OPTION = 5,
+  NVRTC_ERROR_COMPILATION = 6,
+  NVRTC_ERROR_BUILTIN_OPERATION_FAILURE = 7,
+  NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = 8,
+  NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = 9,
+  NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID = 10,
+  NVRTC_ERROR_INTERNAL_ERROR = 11
+} nvrtcResult;
+
+typedef struct _nvrtcProgram *nvrtcProgram;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
diff --git a/dnn/src/cuda/batched_matrix_mul/cublas_lt.cpp b/dnn/src/cuda/batched_matrix_mul/cublas_lt.cpp
index 3fa9f548e99569b34685a95c979722cf882c2412..98e55249a4ea6762973191b563798c211c9a50e6 100644
--- a/dnn/src/cuda/batched_matrix_mul/cublas_lt.cpp
+++ b/dnn/src/cuda/batched_matrix_mul/cublas_lt.cpp
@@ -26,6 +26,7 @@ static inline CUBLASLTMatmulDesc::SizeArgs from_local_size_args(
     return {handle,        transA,        transB,
             args.layout_a, args.layout_b, args.layout_c};
 }
+
 bool BatchedMatrixMulForwardImpl::AlgoCublasLt::is_available(
         const SizeArgs& args) const {
     auto cublasLt_args = from_local_size_args(args);
@@ -35,6 +36,7 @@ bool BatchedMatrixMulForwardImpl::AlgoCublasLt::is_available(
                                      .is_available(cublasLt_args, INT_MAX);
     return res;
 }
+
 size_t BatchedMatrixMulForwardImpl::AlgoCublasLt::get_workspace_in_bytes(
         const SizeArgs& args) const {
     auto cublasLt_args = from_local_size_args(args);
@@ -43,6 +45,7 @@ size_t BatchedMatrixMulForwardImpl::AlgoCublasLt::get_workspace_in_bytes(
     desc.get_algorithm_heuristic(cublasLt_args, INT_MAX, algo);
     return desc.get_workspace_bundle(cublasLt_args, algo).total_size_in_bytes();
 }
+
 void BatchedMatrixMulForwardImpl::AlgoCublasLt::exec(
         const ExecArgs& args) const {
     auto cublasLt_args = from_local_size_args(args);
@@ -89,6 +92,7 @@ void BatchedMatrixMulForwardImpl::AlgoCublasLt::exec(
                                     desc.layout_c, &algo, ws_bundle.get(0),
                                     ws_bundle.get_size(0), stream));
     };
+    
     auto batched_igemm = [&]() {
         auto zero = handle->zero_device();
         auto one = handle->one_device();
@@ -133,6 +137,18 @@ void BatchedMatrixMulForwardImpl::AlgoCublasLt::exec(
     };
 
     ws_bundle.set(args.workspace.raw_ptr);
+#if CUDA_VERSION >= 11000
+    if (desc.dt_compute == CUBLAS_COMPUTE_32I) {
+        batched_igemm();
+    } else if (desc.dt_compute == CUBLAS_COMPUTE_16F) {
+        batched_hgemm();
+    } else if (desc.dt_compute == CUBLAS_COMPUTE_32F) {
+        batched_sgemm();
+    } else {
+        megdnn_throw(
+                megdnn_mangle("compute_type must be int32/float16/float32"));
+    }
+#else
     if (desc.dt_compute == CUDA_R_32I) {
         batched_igemm();
     } else if (desc.dt_compute == CUDA_R_16F) {
@@ -143,5 +159,6 @@ void BatchedMatrixMulForwardImpl::AlgoCublasLt::exec(
         megdnn_throw(
                 megdnn_mangle("compute_type must be int32/float16/float32"));
     }
+#endif
 }
 #endif
diff --git a/dnn/src/cuda/conv_bias/algo.cpp b/dnn/src/cuda/conv_bias/algo.cpp
index d1e55431987630a5ab88962013470738685e8725..4236e031d5efb89da23e03a4890b0a6dcab307c4 100644
--- a/dnn/src/cuda/conv_bias/algo.cpp
+++ b/dnn/src/cuda/conv_bias/algo.cpp
@@ -156,6 +156,9 @@ std::string ConvBiasForwardImpl::AlgoBase::SizeArgs::to_string() const {
         case param::ConvBias::NonlineMode::IDENTITY:
             nonlinear_mode_str = "IDENTITY";
             break;
+        case param::ConvBias::NonlineMode::H_SWISH:
+            nonlinear_mode_str = "H_SWISH";
+            break;
         default:
             megdnn_throw("invalid conv bias nonlinear mode");
     }
diff --git a/dnn/src/cuda/cudnn_wrapper.cpp b/dnn/src/cuda/cudnn_wrapper.cpp
index 4be980812da0ebc04abea0df2f233808fa53f7c3..127caa743a6b635d621a8951f191c7ac180ec43c 100644
--- a/dnn/src/cuda/cudnn_wrapper.cpp
+++ b/dnn/src/cuda/cudnn_wrapper.cpp
@@ -165,6 +165,23 @@ void TensorDesc::set(const TensorLayout& layout,
     }
 }
 
+std::string TensorDesc::to_string() {
+    cudnnDataType_t data_type;
+    int n;
+    int c;
+    int h;
+    int w;
+    int n_stride;
+    int c_stride;
+    int h_stride;
+    int w_stride;
+    cudnn_check(cudnnGetTensor4dDescriptor(desc, &data_type, &n, &c, &h, &w,
+                                           &n_stride, &c_stride, &h_stride,
+                                           &w_stride));
+    return ssprintf("<dtype_%d, %d,%d,%d,%d(%d,%d,%d,%d)>", data_type, n, c, h,
+                    w, n_stride, c_stride, h_stride, w_stride);
+}
+
 template <typename Param>
 FilterDesc<Param>::FilterDesc() {
     cudnn_check(cudnnCreateFilterDescriptor(&desc));
@@ -175,6 +192,20 @@ FilterDesc<Param>::~FilterDesc() {
     cudnn_check(cudnnDestroyFilterDescriptor(desc));
 }
 
+template <typename Param>
+std::string FilterDesc<Param>::to_string() {
+    cudnnDataType_t data_type;
+    cudnnTensorFormat_t format;
+    int k;
+    int c;
+    int h;
+    int w;
+    cudnn_check(cudnnGetFilter4dDescriptor(desc, &data_type, &format, &k, &c,
+                                           &h, &w));
+    return ssprintf("<dtype_%d, format_%d, %d,%d,%d,%d>", data_type,format, k, c, h,
+                    w);
+}
+
 template <typename Param>
 void FilterDesc<Param>::set(
         const typename ConvolutionBase<Param>::CanonizedFilterMeta&
diff --git a/dnn/src/cuda/cudnn_wrapper.h b/dnn/src/cuda/cudnn_wrapper.h
index ec761d3f40f085ef31ae2256ee965d00dbe7ef7b..be35b3c10e72ba53a37edeca5523f882dc930ea9 100644
--- a/dnn/src/cuda/cudnn_wrapper.h
+++ b/dnn/src/cuda/cudnn_wrapper.h
@@ -30,6 +30,7 @@ class TensorDesc {
         //! default layout is nchw
         void set(const TensorLayout& layout, const param::Convolution::Format =
                 param::Convolution::Format::NCHW);
+        std::string to_string();
         ~TensorDesc();
         cudnnTensorDescriptor_t desc;
 };
@@ -39,6 +40,7 @@ class FilterDesc {
     public:
         FilterDesc();
         void set(const typename ConvolutionBase<Param>::CanonizedFilterMeta &meta);
+        std::string to_string();
         ~FilterDesc();
         cudnnFilterDescriptor_t desc;
 };
diff --git a/dnn/src/cuda/matrix_mul/cublas.cpp b/dnn/src/cuda/matrix_mul/cublas.cpp
index 07fcf8f8b884484cec9441673f58f25273daa406..1ece0a100397e347983791f4c772ab9ec4c27e62 100644
--- a/dnn/src/cuda/matrix_mul/cublas.cpp
+++ b/dnn/src/cuda/matrix_mul/cublas.cpp
@@ -25,6 +25,10 @@ using namespace cuda;
 #define SE_CUDA_DATA_HALF CUBLAS_DATA_HALF
 #endif
 
+#if CUDA_VERSION < 11000
+#define CUBLAS_COMPUTE_32I CUDA_R_32I
+#endif
+
 bool MatrixMulForwardImpl::AlgoCuBlas::is_available(
         const SizeArgs& args) const {
     if (args.opr->param().format != param::MatrixMul::Format::DEFAULT)
@@ -117,7 +121,7 @@ void MatrixMulForwardImpl::AlgoCuBlas::exec(const ExecArgs& args) const {
                 args.tensor_b.layout.stride[0], args.tensor_a.raw_ptr,
                 CUDA_R_8I, args.tensor_a.layout.stride[0], zero,
                 args.tensor_c.raw_ptr, CUDA_R_32I,
-                args.tensor_c.layout.stride[0], CUDA_R_32I, CUBLAS_GEMM_DFALT));
+                args.tensor_c.layout.stride[0], CUBLAS_COMPUTE_32I, CUBLAS_GEMM_DFALT));
     };
 
     // Note that cublas takes column-major matrices as inputs,
diff --git a/dnn/src/cuda/matrix_mul/cublasLt_wrapper.cpp b/dnn/src/cuda/matrix_mul/cublasLt_wrapper.cpp
index ee7b4cc692c04294754d2e91292a153193341c55..06849ffbfe98e50f40c39e15a507a7faad4630d0 100644
--- a/dnn/src/cuda/matrix_mul/cublasLt_wrapper.cpp
+++ b/dnn/src/cuda/matrix_mul/cublasLt_wrapper.cpp
@@ -6,10 +6,11 @@
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied.
  */
-#include "src/cuda/matrix_mul/cublasLt_wrapper.h"
 #include "src/common/utils.h"
+#include "src/cuda/matrix_mul/cublasLt_wrapper.h"
 #include "src/cuda/utils.h"
 #if CUDA_VERSION >= 10010
 
@@ -33,6 +34,7 @@ static cudaDataType_t to_cuda_dtype(DType tp) {
     }
 }
 
+#if CUDA_VERSION >= 11000
 static cublasComputeType_t to_cublas_compute_type(DType tp) {
     switch (tp.enumv()) {
         case DTypeEnum::Float16:
@@ -43,10 +45,11 @@ static cublasComputeType_t to_cublas_compute_type(DType tp) {
         case DTypeEnum::QuantizedS32:
             return CUBLAS_COMPUTE_32I;
         default:
-            megdnn_throw(megdnn_mangle(
-                    "dtype must be float16/float32/int32/Qs32"));
+            megdnn_throw(
+                    megdnn_mangle("dtype must be float16/float32/int32/Qs32"));
     }
 }
+#endif
 
 static const char* cuda_type_to_str(cudaDataType_t tp) {
     switch (tp) {
@@ -106,9 +109,15 @@ void CUBLASLTMatmulDesc::set(const SizeArgs& args, bool batched) {
     dt_b = to_cuda_dtype(args.layout_b.dtype);
     dt_a = to_cuda_dtype(args.layout_a.dtype);
     dt_c = to_cuda_dtype(args.layout_c.dtype);
-    dt_compute = to_cublas_compute_type(args.layout_c.dtype);
+
     megdnn_assert(dt_a == dt_b, "matrix A and B should have same precision");
+#if CUDA_VERSION >= 11000
+    dt_compute = to_cublas_compute_type(args.layout_c.dtype);
     cublas_check(cublasLtMatmulDescCreate(&matmul_desc, dt_compute, dt_c));
+#else
+    dt_compute = dt_c;
+    cublas_check(cublasLtMatmulDescCreate(&matmul_desc, dt_compute));
+#endif
     cublas_check(cublasLtMatmulDescSetAttribute(
             matmul_desc, CUBLASLT_MATMUL_DESC_POINTER_MODE, &pm, sizeof(pm)));
 
@@ -262,8 +271,7 @@ WorkspaceBundle CUBLASLTMatmulDesc::get_workspace_bundle(
             dt_c == CUDA_R_32I ? layout_trans_b : layout_b,
             dt_c == CUDA_R_32I ? layout_trans_a : layout_a,
             dt_c == CUDA_R_32I ? layout_trans_c : layout_c,
-            dt_c == CUDA_R_32I ? layout_trans_c : layout_c, &algo,
-            &result);
+            dt_c == CUDA_R_32I ? layout_trans_c : layout_c, &algo, &result);
     // return empty WorkspaceBundle if cublasLtMatmulAlgoCheck() failed
     if (status != CUBLAS_STATUS_SUCCESS)
         return {nullptr, {}};
diff --git a/dnn/src/cuda/matrix_mul/cublasLt_wrapper.h b/dnn/src/cuda/matrix_mul/cublasLt_wrapper.h
index 67d53e36f26a9127a4071bab2213636e6781e1e1..f9615252c09463ccc550dfc69402802c12fdac46 100644
--- a/dnn/src/cuda/matrix_mul/cublasLt_wrapper.h
+++ b/dnn/src/cuda/matrix_mul/cublasLt_wrapper.h
@@ -48,7 +48,11 @@ struct CUBLASLTMatmulDesc {
     bool is_batched;
     cublasLtMatmulDesc_t matmul_desc;
     cudaDataType_t dt_a, dt_b, dt_c;
+#if CUDA_VERSION >= 11000
     cublasComputeType_t dt_compute;
+#else
+    cudaDataType_t dt_compute;
+#endif
     cublasLtMatrixLayout_t layout_a, layout_b, layout_c;
     cublasLtMatrixLayout_t layout_trans_a, layout_trans_b, layout_trans_c;
     size_t workspace_a, workspace_b, workspace_c;
diff --git a/dnn/src/cuda/matrix_mul/cublas_lt.cpp b/dnn/src/cuda/matrix_mul/cublas_lt.cpp
index 9fd7ed656fd2458692b4da6b079888ecb55f5f12..5a6598a7c4cf95b49a55c42cdb93c4a8ff2e2838 100644
--- a/dnn/src/cuda/matrix_mul/cublas_lt.cpp
+++ b/dnn/src/cuda/matrix_mul/cublas_lt.cpp
@@ -128,7 +128,23 @@ void MatrixMulForwardImpl::AlgoCuBlasLt::exec(const ExecArgs& args) const {
             stream));
         cublas_check(cublasLtMatrixTransformDescDestroy(transform_desc));
     };
-    switch(desc.dt_compute) {
+#if CUDA_VERSION >= 11000
+    switch (desc.dt_compute) {
+        case CUBLAS_COMPUTE_16F:
+            hgemm();
+            break;
+        case CUBLAS_COMPUTE_32F:
+            sgemm();
+            break;
+        case CUBLAS_COMPUTE_32I:
+            igemm();
+            break;
+        default:
+            megdnn_throw(megdnn_mangle(
+                    "compute type must be float16/float32/int32"));
+    }
+#else
+    switch (desc.dt_compute) {
         case CUDA_R_16F:
             hgemm();
             break;
@@ -139,8 +155,10 @@ void MatrixMulForwardImpl::AlgoCuBlasLt::exec(const ExecArgs& args) const {
             igemm();
             break;
         default:
-            megdnn_throw(megdnn_mangle("compute type must be float16/float32/int32"));
+            megdnn_throw(megdnn_mangle(
+                    "compute type must be float16/float32/int32"));
     }
+#endif
 }
 #endif
 // vim: syntax=cpp.doxygen
diff --git a/dnn/test/cuda/batch_conv_bias.cpp b/dnn/test/cuda/batch_conv_bias.cpp
index 3ccb155b92709ae5cdc64c0fcfc75c732f58e4ac..0250f26dfd7e60e5f55cb36c454aa097e2d33e0c 100644
--- a/dnn/test/cuda/batch_conv_bias.cpp
+++ b/dnn/test/cuda/batch_conv_bias.cpp
@@ -309,6 +309,9 @@ void benchmark_target_algo(Handle* handle, const std::vector<BenchArgs>& args,
                         arg.f / (1e12);
             TensorShape src{arg.n, arg.ci, arg.hi, arg.wi},
                     filter{arg.co, arg.ci, arg.f, arg.f};
+            if (!algo){
+                algo = "no_name";
+            }
             printf("src=%s, filter=%s, time(algo=%s)=%.2f %.2fTops, "
                    "time(cudnn)=%.2f %.2fTops, time(batched_matmul)=%.2f "
                    "%.2fTops, "
diff --git a/imperative/.gitignore b/imperative/.gitignore
index 35794728108d2a45f6c024dc9ca1d827500968ff..f4f78cf4a05fd187320cb593328003b080331cd2 100644
--- a/imperative/.gitignore
+++ b/imperative/.gitignore
@@ -1,2 +1,3 @@
 Makefile
 /test/imperative_test
+python/megengine/version.py
\ No newline at end of file
diff --git a/imperative/CMakeLists.txt b/imperative/CMakeLists.txt
index 82b36187c81ea78403bd2820e69d981fa1267a48..2bc3b5f617f8345d4fba4b9dcff1bf4c86247c8b 100644
--- a/imperative/CMakeLists.txt
+++ b/imperative/CMakeLists.txt
@@ -70,3 +70,8 @@ add_custom_command(
     COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires-style.txt ${CMAKE_CURRENT_BINARY_DIR}/python/requires-style.txt
     COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires-test.txt ${CMAKE_CURRENT_BINARY_DIR}/python/requires-test.txt
 )
+
+add_custom_command(
+    TARGET ${MODULE_NAME} POST_BUILD
+    COMMAND "${PYTHON_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/python/gen_version.py --output ${CMAKE_CURRENT_BINARY_DIR}/python/megengine/version.py
+)
diff --git a/imperative/python/gen_version.py b/imperative/python/gen_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0e7ef26001f7f1b865e9273db21d9906f404774
--- /dev/null
+++ b/imperative/python/gen_version.py
@@ -0,0 +1,31 @@
+import argparse
+import os
+import subprocess
+
+def get_git_commit(src_dir):
+    try:
+        return subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=src_dir).decode('ascii').strip()
+    except Exception:
+        return 'unknown'
+
+def get_mge_version(version_txt_path):
+    v = {}
+    with open(version_txt_path) as fp:
+        exec(fp.read(), v)
+    return v
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="generate version.py to build path")
+    parser.add_argument("--output", type=str, required=True)
+    args = parser.parse_args()
+    python_dir = os.path.dirname(__file__)
+    version_txt_path = os.path.join(python_dir, 'version_template.py')
+    commit_id = get_git_commit(python_dir)
+    mge_ver_map = get_mge_version(version_txt_path)
+    mge_ver = mge_ver_map['__version__'] if '__version__' in mge_ver_map else 'unknown'
+    mge_intl = mge_ver_map['__internal__'] if '__internal__' in mge_ver_map else False
+    with open(args.output, 'w') as f:
+        f.write("__version__ = '{}'\n".format(mge_ver))
+        f.write("git_version = {}\n".format(repr(commit_id)))
+        if mge_intl:
+            f.write("__internal__ = True\n")
diff --git a/imperative/python/version_template.py b/imperative/python/version_template.py
new file mode 100644
index 0000000000000000000000000000000000000000..956dfc4488a088f5a0ed704a19ccb2b8aa075f66
--- /dev/null
+++ b/imperative/python/version_template.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
+#
+# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+__version__ = "1.3.0.dev"
+
diff --git a/scripts/whl/BUILD_PYTHON_WHL_README.md b/scripts/whl/BUILD_PYTHON_WHL_README.md
index 3a38c1e8f4bc8a826b4e50185481cb1b01ffca22..7143e97db83c1e299d0fc528910dc31a54879007 100755
--- a/scripts/whl/BUILD_PYTHON_WHL_README.md
+++ b/scripts/whl/BUILD_PYTHON_WHL_README.md
@@ -8,7 +8,7 @@
 
 ```bash
 1: please refer to: https://docs.docker.com/engine/security/rootless/ to enable rootless docker env
-2: cd ./scripts/whl/manylinux2010
+2: cd ./scripts/whl/manylinux2014
 3: ./build_image.sh
 
 ```
@@ -56,24 +56,25 @@
 ```
 
 # How to build
+Note: Guarantee the git repo is mounted in docker container, do not use `git submodule update --init` in to init megbrain repo
 ## Build for linux
-* MegBrain delivers `wheel` package with `manylinux2010` tag defined in [PEP-571](https://www.python.org/dev/peps/pep-0571/).
+* MegBrain delivers `wheel` package with `manylinux2014` tag defined in [PEP-571](https://www.python.org/dev/peps/pep-0571/).
 commands:
 ```bash
 export CUDA_ROOT_DIR=/path/to/cuda
 export CUDNN_ROOT_DIR=/path/to/cudnn
 export TENSORRT_ROOT_DIR=/path/to/tensorrt
-./scripts/whl/manylinux2010/build_wheel.sh
+./scripts/whl/manylinux2014/build_wheel_common.sh -sdk cu101
 ```
 
 * And you can find all of the outputs in `output` directory.If you just want to build for a specific Python verison, you can use `ALL_PYTHON` environment variable. eg:
 ```bash
-ALL_PYTHON="36m" ./scripts/whl/manylinux2010/build_wheel.sh
+ALL_PYTHON="36m" ./scripts/whl/manylinux2014/build_wheel_common.sh -sdk cu101
 ```
 
 * If you just want to build with cpu only version, you can set `BUILD_WHL_CPU_ONLY` environment 'ON'. eg:
 ```bash
-BUILD_WHL_CPU_ONLY="ON" ALL_PYTHON="36m" ./scripts/whl/manylinux2010/build_wheel.sh
+BUILD_WHL_CPU_ONLY="ON" ALL_PYTHON="36m" ./scripts/whl/manylinux2014/build_wheel_common.sh -sdk cu101
 ```
 
 ## Build for MacOS
diff --git a/scripts/whl/manylinux2014/Dockerfile b/scripts/whl/manylinux2014/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..5bed0cc3d66c703400c2981472000d0bf50f66a6
--- /dev/null
+++ b/scripts/whl/manylinux2014/Dockerfile
@@ -0,0 +1,15 @@
+FROM quay.io/pypa/manylinux2014_x86_64:2020-12-31-56195b3
+
+ENV UID=1024 \
+    PATH=${PATH}:/usr/local/cuda/bin \
+    LIBRARY_PATH=${LIBRARY_PATH}:/usr/local/cuda/lib64:/usr/local/cuda/lib64/stubs:/opt/cudnn/lib64:/opt/tensorrt/lib \
+    LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/cuda/lib64:/usr/local/cuda/lib64/stubs:/opt/cudnn/lib64:/opt/tensorrt/lib \
+    CPATH=${CPATH}:/usr/local/cuda/include:/opt/cudnn/include:/opt/tensorrt/include
+
+ARG platform
+COPY setup_mirror.sh .
+RUN ./setup_mirror.sh "$platform"
+
+ADD init_image.sh /tmp
+RUN /tmp/init_image.sh && rm -f /tmp/init_image.sh
+
diff --git a/scripts/whl/manylinux2014/build_image.sh b/scripts/whl/manylinux2014/build_image.sh
new file mode 100755
index 0000000000000000000000000000000000000000..aa2e7898a1349c33959becdeff72e7df6e8d8114
--- /dev/null
+++ b/scripts/whl/manylinux2014/build_image.sh
@@ -0,0 +1,5 @@
+#!/bin/bash -e
+
+cd $(dirname $0)
+
+docker build -t env_manylinux2014:latest .
diff --git a/scripts/whl/manylinux2014/build_wheel_common.sh b/scripts/whl/manylinux2014/build_wheel_common.sh
new file mode 100755
index 0000000000000000000000000000000000000000..2ca5e51dd1703eec1a1b63742f093a37002ebe37
--- /dev/null
+++ b/scripts/whl/manylinux2014/build_wheel_common.sh
@@ -0,0 +1,217 @@
+#!/bin/bash
+set -e
+CWD=$(dirname $0)
+BASEDIR=$(readlink -f ${CWD}/../../..)
+OUTPUTDIR=$(readlink -f ${CWD}/output)
+USERID=$(id -u)
+TMPFS_ARGS="--tmpfs /tmp:exec"
+local_path=$(dirname $(readlink -f $0))
+CUDNN_LIB_DIR="/opt/cudnn/lib64/"
+CUDA_LIB_DIR="/usr/local/cuda/lib64/"
+
+CUDA_SDK="unknown"
+function usage() {
+    echo "use '-sdk cu111' to specify cuda toolkit config, also support cu101, cu112"
+}
+
+while [ "$1" != "" ]; do
+    case $1 in
+        -sdk)
+           shift
+           CUDA_SDK=$1
+           shift
+           ;;
+        *)
+            usage
+            exit 1
+    esac
+done
+
+echo "Build with ${CUDA_SDK}"
+
+if [ $CUDA_SDK == "cu101" ];then
+    COPY_LIB_LIST="${CUDA_LIB_DIR}/libnvrtc.so.10.1"
+    EXTRA_CMAKE_FLAG=" -DMGE_WITH_CUDNN_SHARED=OFF" 
+    OUT_DIR="cu101"  
+    BUILD_GCC8="ON"  
+    REQUIR_CUDA_VERSION="10010" 
+    REQUIR_CUDNN_VERSION="7.6.3" 
+    REQUIR_TENSORRT_VERSION="6.0.1.5" 
+elif [ $CUDA_SDK == "cu111" ];then
+    COPY_LIB_LIST="\
+        ${CUDA_LIB_DIR}/libnvrtc.so.11.1:\
+        ${CUDA_LIB_DIR}/libcublasLt.so.11:\
+        ${CUDA_LIB_DIR}/libcublas.so.11:\
+        ${CUDNN_LIB_DIR}/libcudnn_adv_infer.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_adv_train.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_cnn_infer.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_cnn_train.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_ops_infer.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_ops_train.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn.so.8"
+    EXTRA_CMAKE_FLAG=" -DMGE_WITH_CUDNN_SHARED=ON\
+        -gencode arch=compute_61,code=sm_61 \
+        arch=compute_70,code=sm_70 \
+        arch=compute_75,code=sm_75 \
+        arch=compute_80,code=sm_80 \
+        arch=compute_86,code=sm_86 \
+        arch=compute_86,code=compute_86" 
+    OUT_DIR="cu111"  
+    REQUIR_CUDA_VERSION="11010" 
+    REQUIR_CUDNN_VERSION="8.0.5" 
+    REQUIR_TENSORRT_VERSION="7.2.2.3" 
+elif [ $CUDA_SDK == "cu112" ];then
+    COPY_LIB_LIST="\
+        ${CUDA_LIB_DIR}/libnvrtc.so.11.2:\
+        ${CUDA_LIB_DIR}/libcublasLt.so.11:\
+        ${CUDA_LIB_DIR}/libcublas.so.11:\
+        ${CUDNN_LIB_DIR}/libcudnn_adv_infer.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_adv_train.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_cnn_infer.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_cnn_train.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_ops_infer.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn_ops_train.so.8:\
+        ${CUDNN_LIB_DIR}/libcudnn.so.8"
+    EXTRA_CMAKE_FLAG=" -DMGE_WITH_CUDNN_SHARED=ON \
+        -gencode arch=compute_61,code=sm_61 \
+        arch=compute_70,code=sm_70 \
+        arch=compute_75,code=sm_75 \
+        arch=compute_80,code=sm_80 \
+        arch=compute_86,code=sm_86 \
+        arch=compute_86,code=compute_86"  
+    OUT_DIR="cu112"  
+    REQUIR_CUDA_VERSION="11020" 
+    REQUIR_CUDNN_VERSION="8.0.5" 
+    REQUIR_TENSORRT_VERSION="7.2.2.3" 
+else
+    echo "no support sdk ${CUDA_SDK}, please set by '-sdk cu111'"
+    exit -1
+fi
+
+BUILD_WHL_CPU_ONLY=${BUILD_WHL_CPU_ONLY}
+if [[ -z ${BUILD_WHL_CPU_ONLY} ]]
+then
+    BUILD_WHL_CPU_ONLY="OFF"
+fi
+
+echo ${BASEDIR}
+pushd ${BASEDIR}/third_party >/dev/null
+    ./prepare.sh
+popd >/dev/null
+
+cd ${CWD}
+mkdir -p ${OUTPUTDIR}
+
+if [ ${BUILD_WHL_CPU_ONLY} = "OFF" ]; then
+    if [[ -z ${CUDA_ROOT_DIR} ]]; then
+        echo "Environment variable CUDA_ROOT_DIR not set."
+        exit -1
+    fi
+    if [[ -z ${CUDNN_ROOT_DIR} ]]; then
+        echo "Environment variable CUDNN_ROOT_DIR not set."
+        exit -1
+    fi
+    if [[ -z ${TENSORRT_ROOT_DIR} ]]; then
+        echo "Environment variable TENSORRT_ROOT_DIR not set."
+        exit -1
+    fi
+
+    ## YOU SHOULD MODIFY CUDA VERSION AS BELOW WHEN UPGRADE
+    
+
+    CUDA_ROOT_DIR_=${CUDA_ROOT_DIR%*/}
+    CUDNN_ROOT_DIR_=${CUDNN_ROOT_DIR%*/}
+    TENSORRT_ROOT_DIR_=${TENSORRT_ROOT_DIR%*/}
+
+    CUDA_VERSION_PATH=${CUDA_ROOT_DIR_}/include/cuda.h
+    if [ "$REQUIR_CUDA_VERSION" -ge "11000" ];then
+        CUDNN_VERSION_PATH=${CUDNN_ROOT_DIR_}/include/cudnn_version.h
+    else
+        CUDNN_VERSION_PATH=${CUDNN_ROOT_DIR_}/include/cudnn.h
+    fi
+    TENSORRT_VERSION_PATH=${TENSORRT_ROOT_DIR_}/include/NvInferVersion.h
+
+    if [ ! -e $CUDA_VERSION_PATH ] ; then
+        echo file $CUDA_VERSION_PATH is not exist
+        echo please check the Environment must use CUDA-$REQUIR_CUDA_VERSION
+        exit -1
+    fi
+    if [ ! -e $CUDNN_VERSION_PATH ] ; then
+        echo file $CUDNN_VERSION_PATH is not exist
+        echo please check the Environment must use CUDNN-V$REQUIR_CUDNN_VERSION
+        exit -1
+    fi
+    if [ ! -e $TENSORRT_VERSION_PATH ] ; then
+        echo file $TENSORRT_VERSION_PATH is not exist
+        echo please check the Environment must use TensorRT-$REQUIR_TENSORRT_VERSION
+        exit -1
+    fi
+
+    CUDA_VERSION_CONTEXT=$(head -300 ${CUDA_VERSION_PATH})
+    CUDNN_VERSION_CONTEXT=$(head -62 ${CUDNN_VERSION_PATH})
+    TENSORRT_VERSION_CONTEXT=$(tail -12 ${TENSORRT_VERSION_PATH})
+
+    if [ "$REQUIR_CUDA_VERSION" -ge "11000" ];then
+        CUDA_API_VERSION=$(echo $CUDA_VERSION_CONTEXT | grep -Eo "define CUDA_VERSION * +([0-9]+)")
+    else
+        CUDA_API_VERSION=$(echo $CUDA_VERSION_CONTEXT | grep -Eo "define __CUDA_API_VERSION * +([0-9]+)")
+    fi
+    CUDA_VERSION=${CUDA_API_VERSION:0-5}
+    echo CUDA_VERSION:$CUDA_VERSION
+
+    CUDNN_VERSION_MAJOR=$(echo $CUDNN_VERSION_CONTEXT | grep -Eo "define CUDNN_MAJOR * +([0-9]+)")
+    CUDNN_VERSION_MINOR=$(echo $CUDNN_VERSION_CONTEXT | grep -Eo "define CUDNN_MINOR * +([0-9]+)")
+    CUDNN_VERSION_PATCH=$(echo $CUDNN_VERSION_CONTEXT | grep -Eo "define CUDNN_PATCHLEVEL * +([0-9]+)")
+    CUDNN_VERSION=${CUDNN_VERSION_MAJOR:0-1}.${CUDNN_VERSION_MINOR:0-1}.${CUDNN_VERSION_PATCH:0-1}
+    echo CUDNN_VERSION:$CUDNN_VERSION
+
+    TENSORRT_VERSION_MAJOR=$(echo $TENSORRT_VERSION_CONTEXT | grep -Eo "NV_TENSORRT_MAJOR * +([0-9]+)")
+    TENSORRT_VERSION_MINOR=$(echo $TENSORRT_VERSION_CONTEXT | grep -Eo "NV_TENSORRT_MINOR * +([0-9]+)")
+    TENSORRT_VERSION_PATCH=$(echo $TENSORRT_VERSION_CONTEXT | grep -Eo "NV_TENSORRT_PATCH * +([0-9]+)")
+    TENSORRT_VERSION_BUILD=$(echo $TENSORRT_VERSION_CONTEXT | grep -Eo "NV_TENSORRT_BUILD * +([0-9]+)")
+    TENSORRT_VERSION=${TENSORRT_VERSION_MAJOR:0-1}.${TENSORRT_VERSION_MINOR:0-1}.${TENSORRT_VERSION_PATCH:0-1}.${TENSORRT_VERSION_BUILD:0-1}
+    echo TENSORRT_VERSION:$TENSORRT_VERSION
+
+    if [ $CUDA_VERSION != $REQUIR_CUDA_VERSION ] ; then
+        echo please check the Environment must use CUDA-10.1 NO.$REQUIR_CUDA_VERSION
+        exit -1
+    fi
+
+    if [ $CUDNN_VERSION != $REQUIR_CUDNN_VERSION ] ; then
+        echo please check the Environment must use CUDNN-V$REQUIR_CUDNN_VERSION
+        exit -1
+    fi
+
+    if [ $TENSORRT_VERSION != $REQUIR_TENSORRT_VERSION ] ; then
+        echo please check the Environment must use TENSORRT-$REQUIR_TENSORRT_VERSION
+        exit -1
+    fi
+fi
+
+if [[ -z ${BUILD_GCC8} ]];then
+    BUILD_GCC8=OFF
+fi
+
+if [ "$BUILD_GCC8" == "ON" ];then
+    run_cmd="scl enable devtoolset-8 /home/code/scripts/whl/manylinux2014/do_build_common.sh"
+else
+    run_cmd="/home/code/scripts/whl/manylinux2014/do_build_common.sh"
+fi
+
+docker run --rm -it $TMPFS_ARGS \
+    -e UID=${USERID} \
+    -e LOCAL_VERSION=${LOCAL_VERSION} \
+    -e BUILD_WHL_CPU_ONLY=${BUILD_WHL_CPU_ONLY} \
+    -e ALL_PYTHON="${ALL_PYTHON}" \
+    -e EXTRA_CMAKE_FLAG="$EXTRA_CMAKE_FLAG" \
+    -e COPY_LIB_LIST="$COPY_LIB_LIST"  \
+    -e OUT_DIR="$OUT_DIR"  \
+    -v ${CUDA_ROOT_DIR}:/usr/local/cuda \
+    -v ${CUDNN_ROOT_DIR}:/opt/cudnn \
+    -v ${TENSORRT_ROOT_DIR}:/opt/tensorrt \
+    -v ${BASEDIR}:/home/code \
+    -v ${OUTPUTDIR}:/home/output:rw \
+    env_manylinux2014:latest /bin/bash -c "$run_cmd"
+
+
+
diff --git a/scripts/whl/manylinux2014/do_build_common.sh b/scripts/whl/manylinux2014/do_build_common.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d7fdbd0ce1338208548e71ff851524610ce95bf0
--- /dev/null
+++ b/scripts/whl/manylinux2014/do_build_common.sh
@@ -0,0 +1,136 @@
+#!/bin/bash -ex
+
+function handle_strip() {
+    echo "now handle strip $1"
+    objcopy --only-keep-debug $1 $1.dbg
+    strip -s $1
+    objcopy --add-gnu-debuglink=$1.dbg $1
+    rm $1.dbg
+}
+
+function full_copy_so(){
+    lib_path=$1
+    dst_dir=$2
+    append_rpath=$3
+    lib_name=$(basename $lib_path)
+    cp $lib_path $dst_dir/$lib_name
+    if [ "$append_rpath" != "" ];then
+        ori_rpath=$(patchelf --print-rpath $dst_dir/$lib_name)
+        if [ "$ori_rpath" != "" ];then
+            patchelf --set-rpath "$ori_rpath:$append_rpath" $dst_dir/$lib_name   
+        else
+            patchelf --set-rpath "$append_rpath" $dst_dir/$lib_name   
+        fi
+    fi
+}
+
+function patch_elf_depend_lib() {
+    echo "handle common depend lib"
+    LIBS_DIR=${BUILD_DIR}/staging/megengine/core/lib
+    mkdir -p ${LIBS_DIR}
+    cp /usr/lib64/libatomic.so.1 ${LIBS_DIR}
+
+    patchelf --remove-rpath ${BUILD_DIR}/staging/megengine/core/_imperative_rt.so
+    patchelf --force-rpath --set-rpath '$ORIGIN/lib' ${BUILD_DIR}/staging/megengine/core/_imperative_rt.so
+    cp ${BUILD_DIR}/src/libmegengine_export.so ${LIBS_DIR}
+    patchelf --remove-rpath ${LIBS_DIR}/libmegengine_export.so
+    patchelf --force-rpath --set-rpath '$ORIGIN/.' ${LIBS_DIR}/libmegengine_export.so
+
+    cp ${BUILD_DIR}/src/libmegengine_export.so ${LIBS_DIR}
+    patchelf --remove-rpath ${LIBS_DIR}/libmegengine_export.so
+    patchelf --force-rpath --set-rpath '$ORIGIN/.' ${LIBS_DIR}/libmegengine_export.so
+
+
+    if [ ${BUILD_WHL_CPU_ONLY} = "OFF" ]; then
+        echo "handle cuda lib"
+        cp ${BUILD_DIR}/dnn/cuda-stub/libcuda_stub.so ${LIBS_DIR}
+        cp /usr/local/cuda/lib64/libnvToolsExt.so.1 ${LIBS_DIR}
+        IFS=: read -a lib_name_array <<<"$COPY_LIB_LIST"
+        append_rpath='$ORIGIN/.'
+        for lib_name in ${lib_name_array[@]};do
+            full_copy_so $lib_name ${LIBS_DIR} $lib_append_rpath
+        done
+    fi
+}
+
+
+ALL_PYTHON=${ALL_PYTHON}
+if [[ -z ${ALL_PYTHON} ]]
+then
+    ALL_PYTHON="35m 36m 37m 38"
+fi
+
+BUILD_WHL_CPU_ONLY=${BUILD_WHL_CPU_ONLY}
+if [[ -z ${BUILD_WHL_CPU_ONLY} ]]
+then
+    BUILD_WHL_CPU_ONLY="OFF"
+fi
+
+SRC_DIR=$(readlink -f "`dirname $0`/../../../")
+BUILD_DIR=${SRC_DIR}/build_dir/host/MGE_WITH_CUDA_OFF/MGE_INFERENCE_ONLY_OFF/Release/build/
+if [ ${BUILD_WHL_CPU_ONLY} = "OFF" ]; then
+    BUILD_DIR=${SRC_DIR}/build_dir/host/MGE_WITH_CUDA_ON/MGE_INFERENCE_ONLY_OFF/Release/build/
+fi
+NEW_LIB_PATH=core/lib
+for ver in ${ALL_PYTHON}
+do
+    USE_AUDITWHEEL="ON"
+    python_ver=${ver:0:2}
+    MAJOR=${python_ver:0:1}
+    MINOR=${ver:1}
+    PYTHON_DIR=/opt/python/cp${python_ver}-cp${ver}/
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} ${EXTRA_CMAKE_FLAG}"
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DCMAKE_BUILD_TYPE=RelWithDebInfo"
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DCMAKE_PREFIX_PATH=${PYTHON_DIR}"
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DPYTHON_EXECUTABLE=${PYTHON_DIR}/bin/python3"
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DPYTHON_LIBRARY=${PYTHON_DIR}lib/"
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DPYTHON_INCLUDE_DIR=${PYTHON_DIR}include/python${MAJOR}.${MINOR}"
+    export EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DMGE_WITH_ATLAS=ON"
+
+    if [ ${BUILD_WHL_CPU_ONLY} = "OFF" ]; then
+        ${SRC_DIR}/scripts/cmake-build/host_build.sh -c -t -r
+    else
+        ${SRC_DIR}/scripts/cmake-build/host_build.sh -t -r
+    fi
+
+    cd ${BUILD_DIR}
+    rm -rf staging
+    mkdir -p staging
+    cp -a imperative/python/{megengine,setup.py,requires.txt,requires-style.txt,requires-test.txt} staging/
+
+
+
+    handle_strip ${BUILD_DIR}/src/libmegengine_export.so
+
+    cd ${BUILD_DIR}/staging/megengine/core
+    handle_strip _imperative_rt.so
+
+    mkdir -p lib/ucx
+
+
+
+    if [ ${USE_AUDITWHEEL} = "OFF" ]; then
+        patch_elf_depend_lib
+    fi
+
+    cd ${BUILD_DIR}/staging/
+    ${PYTHON_DIR}/bin/python setup.py bdist_wheel
+    cd /home/output
+    if [ ${USE_AUDITWHEEL} = "ON" ]; then
+        LD_LIBRARY_PATH=${BUILD_DIR}/dnn/cuda-stub:$LD_LIBRARY_PATH auditwheel repair -L ${NEW_LIB_PATH} ${BUILD_DIR}/staging/dist/Meg*.whl
+    else
+        mkdir -p ${SRC_DIR}/scripts/whl/manylinux2014/output/wheelhouse/${OUT_DIR}
+        cd ${BUILD_DIR}/staging/dist/
+        org_whl_name=`ls Meg*${ver}*.whl`
+        compat_whl_name=`echo ${org_whl_name} | sed 's/linux/manylinux2014/'`
+        echo "org whl name: ${org_whl_name}"
+        echo "comapt whl name: ${compat_whl_name}"
+        mv ${org_whl_name} ${SRC_DIR}/scripts/whl/manylinux2014/output/wheelhouse/${OUT_DIR}/${compat_whl_name}
+        cd /home/output
+    fi
+    chown -R ${UID}.${UID} .
+    # compat for root-less docker env to remove output at host side
+    chmod -R 777 .
+    echo "python $ver done"
+done
+
diff --git a/scripts/whl/manylinux2014/init_image.sh b/scripts/whl/manylinux2014/init_image.sh
new file mode 100755
index 0000000000000000000000000000000000000000..cbdf628b865801abccaac2d2e272553ca17fff74
--- /dev/null
+++ b/scripts/whl/manylinux2014/init_image.sh
@@ -0,0 +1,70 @@
+#!/bin/bash -e
+
+GET_PIP_URL='https://bootstrap.pypa.io/get-pip.py'
+SWIG_URL='https://downloads.sourceforge.net/project/swig/swig/swig-3.0.12/swig-3.0.12.tar.gz?use_mirror=autoselect'
+LLVM_URL='https://github.com/llvm-mirror/llvm/archive/release_60.tar.gz' 
+CLANG_URL='https://github.com/llvm-mirror/clang/archive/release_60.tar.gz'
+
+
+yum install -y pcre-devel devtoolset-9-libatomic-devel.x86_64
+yum install -y devtoolset-8 devtoolset-8-libatomic-devel.x86_64
+
+for ver in 35m 36m 37m 38 
+do
+    python_ver=${ver:0:2}
+    curl ${GET_PIP_URL} | /opt/python/cp${python_ver}-cp${ver}/bin/python - \
+	--no-cache-dir --only-binary :all:
+    /opt/python/cp${python_ver}-cp${ver}/bin/pip install \
+	--no-cache-dir --only-binary :all: numpy==1.18.1 setuptools==46.1.3
+done
+
+pushd /home >/dev/null
+    echo "Install swig"
+    curl -sSL ${SWIG_URL} | tar xz
+    pushd swig-3.0.12 >/dev/null
+        mkdir build
+       	pushd build >/dev/null
+	    ../configure
+	    make -j$(nproc)
+	    make install
+        popd >/dev/null
+    popd >/dev/null
+    rm -rf swig-3.0.12
+    
+    echo "Install llvm"
+    curl -sSL ${LLVM_URL} | tar xz
+    pushd llvm-release_60 >/dev/null
+        mkdir build
+       	pushd build >/dev/null
+            cmake .. -DCMAKE_PREFIX_PATH=/opt/python/cp36-cp36m/ \
+		-DCMAKE_BUILD_TYPE=Release
+	    make -j$(nproc)
+	    make install
+	popd >/dev/null
+    popd >/dev/null
+    rm -rf llvm-release_60
+
+    echo "Install clang"
+    curl -sSL ${CLANG_URL} | tar xz
+    pushd clang-release_60 >/dev/null
+        mkdir build
+       	pushd build >/dev/null
+            cmake .. -DCMAKE_PREFIX_PATH=/opt/python/cp36-cp36m/ \
+                -DCMAKE_BUILD_TYPE=Release
+	    make -j$(nproc)
+	    make install
+	popd >/dev/null
+    popd >/dev/null
+    rm -rf clang-release_60 
+popd >/dev/null
+
+pushd /tmp >/dev/null
+    curl -sSL https://github.com/NixOS/patchelf/archive/0.12.tar.gz | tar xz
+    pushd /tmp/patchelf-0.12 >/dev/null
+        sed -i '331s/32/64/' ./src/patchelf.cc
+        ./bootstrap.sh && ./configure && make install-strip
+    popd
+    rm -rf /tmp/patchelf-0.12
+popd
+
+yum clean all
diff --git a/scripts/whl/manylinux2014/setup_mirror.sh b/scripts/whl/manylinux2014/setup_mirror.sh
new file mode 100755
index 0000000000000000000000000000000000000000..93c541a6f006ac13ab96c9f02b3057a97ad100e7
--- /dev/null
+++ b/scripts/whl/manylinux2014/setup_mirror.sh
@@ -0,0 +1,65 @@
+#!/bin/bash
+
+set -e
+
+function set_tuna_yum_mirror() {
+    cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.bak
+    local repo=/etc/yum.repos.d/CentOS-Base.repo
+    local plugin=/etc/yum/pluginconf.d/fastestmirror.conf
+    sed -i "s/mirrorlist=/#mirrorlist=/g" $repo
+    sed -i "s/#baseurl/baseurl/g" $repo
+    sed -i "s/mirror.centos.org/mirrors.tuna.tsinghua.edu.cn/g" $repo
+    sed -i "s/http/https/g" $repo
+    sed -i "s/enabled=1/enabled=0/g" $plugin
+    yum clean all
+    # Build on brainpp unable to pull epel reo metadata so disable this
+    # https://unix.stackexchange.com/questions/148144/unable-to-pull-epel-repository-metadata
+    yum --disablerepo="epel" update nss
+    yum makecache
+}
+
+function set_epel() {
+    mv /etc/yum.repos.d/epel.repo /etc/yum.repos.d/epel.repo.backup
+    mv /etc/yum.repos.d/epel-testing.repo /etc/yum.repos.d/epel-testing.repo.backup
+    curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
+}
+
+function set_yum_mirror() {
+    mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
+    curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
+    yum makecache 
+}
+
+function set_pip_mirror() {
+cat > /etc/pip.conf <<EOF
+[global]
+timeout = 180
+index-url = https://mirrors.aliyun.com/pypi/simple
+extra-index-url = 
+    http://mirrors.i.brainpp.cn/pypi/simple/
+    http://pypi.i.brainpp.cn/brain/dev/+simple
+    https://pypi.tuna.tsinghua.edu.cn/simple
+trusted-host =
+    mirrors.i.brainpp.cn
+    pypi.i.brainpp.cn
+    pypi.tuna.tsinghua.edu.cn
+    mirrors.aliyun.com
+EOF
+}
+
+
+function main() {
+    local platform=$1
+    case $platform in
+        brainpp)
+            set_epel
+            set_yum_mirror
+            set_pip_mirror
+            ;;
+        *)
+            echo "No setup required"
+            ;;
+    esac
+}
+
+main "$@"
diff --git a/src/opr/impl/standalone/nms_opr.cpp b/src/opr/impl/standalone/nms_opr.cpp
index 3a88a9a8669dba1c21c3cafff965c00c6b13ec89..bd1cf9672a42de791a39f27b73f27e16b3dc1041 100644
--- a/src/opr/impl/standalone/nms_opr.cpp
+++ b/src/opr/impl/standalone/nms_opr.cpp
@@ -81,8 +81,9 @@ void NMSKeep::CUDAKern::exec(const NMSKeep* opr, const DeviceTensorND& inp,
     init(opr, inp.shape());
 
     auto inp_ptr = inp.ptr<float>();
-    auto dev_overlap_mask = reinterpret_cast<uint64_t*>(workspace.raw_ptr()),
-         dev_rm_mask = reinterpret_cast<uint64_t*>(
+    void* workspace_ptr = workspace.raw_ptr();
+    auto dev_overlap_mask = reinterpret_cast<uint64_t*>(workspace_ptr),
+         dev_rm_mask = (uint64_t*)(
                  workspace.raw_ptr() + m_workspace_overlap_mask_bytes_align);
     auto out_idx_ptr = reinterpret_cast<uint32_t*>(out_idx.ptr<int32_t>()),
          out_size_ptr = reinterpret_cast<uint32_t*>(out_size.ptr<int32_t>());
diff --git a/src/tensorrt/impl/opr_replace.cpp b/src/tensorrt/impl/opr_replace.cpp
index ad9d1e8a50a8f3750847f8a962c6b575ce5be293..c48599f0002114bfe67b17e64a30e147eaf5adc5 100644
--- a/src/tensorrt/impl/opr_replace.cpp
+++ b/src/tensorrt/impl/opr_replace.cpp
@@ -27,6 +27,9 @@
 #include "megbrain/gopt/inference.h"
 #include "megbrain/gopt/misc.h"
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 using namespace mgb;
 using namespace gopt;
 using namespace cg;
@@ -1749,6 +1752,7 @@ void mgb::tensorrt::transform_dest_vars_inplace(
     optimizer.apply_inplace(dest_vars);
 }
 
+#pragma GCC diagnostic pop
 #endif
 
 // vim: syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}
diff --git a/src/tensorrt/test/make_trt_net.cpp b/src/tensorrt/test/make_trt_net.cpp
index 5b72916cf197fdc063ca540ef8228103823713ee..b1974f39b26b3665a93885df82aa5ad54a0d43ae 100644
--- a/src/tensorrt/test/make_trt_net.cpp
+++ b/src/tensorrt/test/make_trt_net.cpp
@@ -20,7 +20,8 @@
 #include "megbrain/utils/debug.h"
 
 #if MGB_ENABLE_TENSOR_RT
-
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #include "megbrain/tensorrt/tensorrt_opr.h"
 #include "make_trt_net.h"
 
@@ -111,7 +112,8 @@ intl::SimpleQuantizedTensorRTNetwork::SimpleQuantizedTensorRTNetwork() {
     host_b = range_gen({1, 8, 1, 1});
 
     {
-        float* ptr = reinterpret_cast<float*>(host_w->raw_ptr());
+        void* w_ptr = host_w->raw_ptr();
+        float* ptr = reinterpret_cast<float*>(w_ptr);
         ptr[0] = -127*1.1f;
         ptr[1] = 127*1.1f;
     }
@@ -362,6 +364,7 @@ intl::ConcatConvTensorRTNetwork::create_trt_network(bool has_batch_dim) {
     return std::make_pair(builder, network);
 }
 
+#pragma GCC diagnostic pop
 #endif  // MGB_ENABLE_TENSOR_RT
 
 // vim: syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}