// Auto-generated, do not edit.

extern "C" {
CUresult CUDAAPI cuGetErrorString(CUresult error, const char **pStr) {
  using FuncPtr = CUresult(CUDAAPI *)(CUresult, const char **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuGetErrorString");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(error, pStr);
}

CUresult CUDAAPI cuGetErrorName(CUresult error, const char **pStr) {
  using FuncPtr = CUresult(CUDAAPI *)(CUresult, const char **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuGetErrorName");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(error, pStr);
}

CUresult CUDAAPI cuInit(unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuInit");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(Flags);
}

CUresult CUDAAPI cuDriverGetVersion(int *driverVersion) {
  using FuncPtr = CUresult(CUDAAPI *)(int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDriverGetVersion");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(driverVersion);
}

CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(device, ordinal);
}

CUresult CUDAAPI cuDeviceGetCount(int *count) {
  using FuncPtr = CUresult(CUDAAPI *)(int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetCount");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(count);
}

CUresult CUDAAPI cuDeviceGetName(char *name, int len, CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(char *, int, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetName");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(name, len, dev);
}

CUresult CUDAAPI cuDeviceGetUuid(CUuuid *uuid, CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(CUuuid *, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetUuid");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(uuid, dev);
}

CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(size_t *, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceTotalMem_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(bytes, dev);
}

CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib,
                                      CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, CUdevice_attribute, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pi, attrib, dev);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop,
                                                         CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevprop *, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetProperties");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(prop, dev);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuDeviceComputeCapability(int *major,
                                                             int *minor,
                                                             CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, int *, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceComputeCapability");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(major, minor, dev);
}

CUresult CUDAAPI cuDevicePrimaryCtxRetain(CUcontext *pctx, CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext *, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDevicePrimaryCtxRetain");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pctx, dev);
}

CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDevicePrimaryCtxRelease");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dev);
}

CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDevicePrimaryCtxSetFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dev, flags);
}

CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags,
                                            int *active) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice, unsigned int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDevicePrimaryCtxGetState");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dev, flags, active);
}

CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDevicePrimaryCtxReset");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dev);
}

CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, unsigned int flags,
                             CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext *, unsigned int, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxCreate_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pctx, flags, dev);
}

CUresult CUDAAPI cuCtxDestroy(CUcontext ctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxDestroy_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ctx);
}

CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxPushCurrent_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ctx);
}

CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxPopCurrent_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pctx);
}

CUresult CUDAAPI cuCtxSetCurrent(CUcontext ctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxSetCurrent");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ctx);
}

CUresult CUDAAPI cuCtxGetCurrent(CUcontext *pctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetCurrent");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pctx);
}

CUresult CUDAAPI cuCtxGetDevice(CUdevice *device) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetDevice");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(device);
}

CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags) {
  using FuncPtr = CUresult(CUDAAPI *)(unsigned int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(flags);
}

CUresult CUDAAPI cuCtxSynchronize(void) {
  using FuncPtr = CUresult(CUDAAPI *)();
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxSynchronize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr();
}

CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value) {
  using FuncPtr = CUresult(CUDAAPI *)(CUlimit, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxSetLimit");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(limit, value);
}

CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit) {
  using FuncPtr = CUresult(CUDAAPI *)(size_t *, CUlimit);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetLimit");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pvalue, limit);
}

CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunc_cache *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetCacheConfig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pconfig);
}

CUresult CUDAAPI cuCtxSetCacheConfig(CUfunc_cache config) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunc_cache);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxSetCacheConfig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(config);
}

CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig) {
  using FuncPtr = CUresult(CUDAAPI *)(CUsharedconfig *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetSharedMemConfig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pConfig);
}

CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config) {
  using FuncPtr = CUresult(CUDAAPI *)(CUsharedconfig);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxSetSharedMemConfig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(config);
}

CUresult CUDAAPI cuCtxGetApiVersion(CUcontext ctx, unsigned int *version) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext, unsigned int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetApiVersion");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ctx, version);
}

CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority,
                                             int *greatestPriority) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxGetStreamPriorityRange");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(leastPriority, greatestPriority);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuCtxAttach(CUcontext *pctx,
                                               unsigned int flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxAttach");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pctx, flags);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuCtxDetach(CUcontext ctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxDetach");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ctx);
}

CUresult CUDAAPI cuModuleLoad(CUmodule *module, const char *fname) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmodule *, const char *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleLoad");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(module, fname);
}

CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmodule *, const void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleLoadData");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(module, image);
}

CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image,
                                    unsigned int numOptions,
                                    CUjit_option *options,
                                    void **optionValues) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmodule *, const void *, unsigned int,
                                      CUjit_option *, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleLoadDataEx");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(module, image, numOptions, options, optionValues);
}

CUresult CUDAAPI cuModuleLoadFatBinary(CUmodule *module, const void *fatCubin) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmodule *, const void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleLoadFatBinary");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(module, fatCubin);
}

CUresult CUDAAPI cuModuleUnload(CUmodule hmod) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmodule);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleUnload");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hmod);
}

CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod,
                                     const char *name) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction *, CUmodule, const char *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleGetFunction");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, hmod, name);
}

CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes,
                                   CUmodule hmod, const char *name) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr *, size_t *, CUmodule, const char *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleGetGlobal_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dptr, bytes, hmod, name);
}

CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod,
                                   const char *name) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref *, CUmodule, const char *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleGetTexRef");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pTexRef, hmod, name);
}

CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod,
                                    const char *name) {
  using FuncPtr = CUresult(CUDAAPI *)(CUsurfref *, CUmodule, const char *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuModuleGetSurfRef");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pSurfRef, hmod, name);
}

CUresult CUDAAPI cuLinkCreate(unsigned int numOptions, CUjit_option *options,
                              void **optionValues, CUlinkState *stateOut) {
  using FuncPtr =
      CUresult(CUDAAPI *)(unsigned int, CUjit_option *, void **, CUlinkState *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLinkCreate_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(numOptions, options, optionValues, stateOut);
}

CUresult CUDAAPI cuLinkAddData(CUlinkState state, CUjitInputType type,
                               void *data, size_t size, const char *name,
                               unsigned int numOptions, CUjit_option *options,
                               void **optionValues) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUlinkState, CUjitInputType, void *, size_t,
                          const char *, unsigned int, CUjit_option *, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLinkAddData_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(state, type, data, size, name, numOptions, options,
                  optionValues);
}

CUresult CUDAAPI cuLinkAddFile(CUlinkState state, CUjitInputType type,
                               const char *path, unsigned int numOptions,
                               CUjit_option *options, void **optionValues) {
  using FuncPtr = CUresult(CUDAAPI *)(CUlinkState, CUjitInputType, const char *,
                                      unsigned int, CUjit_option *, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLinkAddFile_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(state, type, path, numOptions, options, optionValues);
}

CUresult CUDAAPI cuLinkComplete(CUlinkState state, void **cubinOut,
                                size_t *sizeOut) {
  using FuncPtr = CUresult(CUDAAPI *)(CUlinkState, void **, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLinkComplete");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(state, cubinOut, sizeOut);
}

CUresult CUDAAPI cuLinkDestroy(CUlinkState state) {
  using FuncPtr = CUresult(CUDAAPI *)(CUlinkState);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLinkDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(state);
}

CUresult CUDAAPI cuMemGetInfo(size_t *free, size_t *total) {
  using FuncPtr = CUresult(CUDAAPI *)(size_t *, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemGetInfo_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(free, total);
}

CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, size_t bytesize) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemAlloc_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dptr, bytesize);
}

CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch,
                                 size_t WidthInBytes, size_t Height,
                                 unsigned int ElementSizeBytes) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, size_t *, size_t, size_t,
                                      unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemAllocPitch_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dptr, pPitch, WidthInBytes, Height, ElementSizeBytes);
}

CUresult CUDAAPI cuMemFree(CUdeviceptr dptr) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemFree_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dptr);
}

CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize,
                                      CUdeviceptr dptr) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, size_t *, CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemGetAddressRange_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pbase, psize, dptr);
}

CUresult CUDAAPI cuMemAllocHost(void **pp, size_t bytesize) {
  using FuncPtr = CUresult(CUDAAPI *)(void **, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemAllocHost_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pp, bytesize);
}

CUresult CUDAAPI cuMemFreeHost(void *p) {
  using FuncPtr = CUresult(CUDAAPI *)(void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemFreeHost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(p);
}

CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize,
                                unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(void **, size_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemHostAlloc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pp, bytesize, Flags);
}

CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p,
                                           unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, void *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemHostGetDevicePointer_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pdptr, p, Flags);
}

CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p) {
  using FuncPtr = CUresult(CUDAAPI *)(unsigned int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemHostGetFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pFlags, p);
}

CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize,
                                   unsigned int flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, size_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemAllocManaged");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dptr, bytesize, flags);
}

CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdevice *, const char *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetByPCIBusId");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dev, pciBusId);
}

CUresult CUDAAPI cuDeviceGetPCIBusId(char *pciBusId, int len, CUdevice dev) {
  using FuncPtr = CUresult(CUDAAPI *)(char *, int, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetPCIBusId");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pciBusId, len, dev);
}

CUresult CUDAAPI cuIpcGetEventHandle(CUipcEventHandle *pHandle, CUevent event) {
  using FuncPtr = CUresult(CUDAAPI *)(CUipcEventHandle *, CUevent);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuIpcGetEventHandle");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pHandle, event);
}

CUresult CUDAAPI cuIpcOpenEventHandle(CUevent *phEvent,
                                      CUipcEventHandle handle) {
  using FuncPtr = CUresult(CUDAAPI *)(CUevent *, CUipcEventHandle);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuIpcOpenEventHandle");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phEvent, handle);
}

CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr) {
  using FuncPtr = CUresult(CUDAAPI *)(CUipcMemHandle *, CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuIpcGetMemHandle");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pHandle, dptr);
}

CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle,
                                    unsigned int Flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr *, CUipcMemHandle, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuIpcOpenMemHandle");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pdptr, handle, Flags);
}

CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuIpcCloseMemHandle");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dptr);
}

CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize,
                                   unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(void *, size_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemHostRegister_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(p, bytesize, Flags);
}

CUresult CUDAAPI cuMemHostUnregister(void *p) {
  using FuncPtr = CUresult(CUDAAPI *)(void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemHostUnregister");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(p);
}

CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dst, src, ByteCount);
}

CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext,
                              CUdeviceptr srcDevice, CUcontext srcContext,
                              size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, CUcontext, CUdeviceptr,
                                      CUcontext, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyPeer");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstContext, srcDevice, srcContext, ByteCount);
}

CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost,
                              size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, const void *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyHtoD_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, srcHost, ByteCount);
}

CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice,
                              size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(void *, CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyDtoH_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstHost, srcDevice, ByteCount);
}

CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice,
                              size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyDtoD_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, srcDevice, ByteCount);
}

CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset,
                              CUdeviceptr srcDevice, size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray, size_t, CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyDtoA_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstArray, dstOffset, srcDevice, ByteCount);
}

CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray,
                              size_t srcOffset, size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, CUarray, size_t, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyAtoD_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, srcArray, srcOffset, ByteCount);
}

CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset,
                              const void *srcHost, size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray, size_t, const void *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyHtoA_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstArray, dstOffset, srcHost, ByteCount);
}

CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset,
                              size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(void *, CUarray, size_t, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyAtoH_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstHost, srcArray, srcOffset, ByteCount);
}

CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset,
                              CUarray srcArray, size_t srcOffset,
                              size_t ByteCount) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray, size_t, CUarray, size_t, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyAtoA_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstArray, dstOffset, srcArray, srcOffset, ByteCount);
}

CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY2D *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy2D_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy);
}

CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY2D *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy2DUnaligned_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy);
}

CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY3D *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy3D_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy);
}

CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY3D_PEER *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy3DPeer");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy);
}

CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src,
                               size_t ByteCount, CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dst, src, ByteCount, hStream);
}

CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext,
                                   CUdeviceptr srcDevice, CUcontext srcContext,
                                   size_t ByteCount, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, CUcontext, CUdeviceptr,
                                      CUcontext, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyPeerAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstContext, srcDevice, srcContext, ByteCount,
                  hStream);
}

CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost,
                                   size_t ByteCount, CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, const void *, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyHtoDAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, srcHost, ByteCount, hStream);
}

CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice,
                                   size_t ByteCount, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(void *, CUdeviceptr, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyDtoHAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstHost, srcDevice, ByteCount, hStream);
}

CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice,
                                   size_t ByteCount, CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, CUdeviceptr, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyDtoDAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, srcDevice, ByteCount, hStream);
}

CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset,
                                   const void *srcHost, size_t ByteCount,
                                   CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUarray, size_t, const void *, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyHtoAAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstArray, dstOffset, srcHost, ByteCount, hStream);
}

CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray,
                                   size_t srcOffset, size_t ByteCount,
                                   CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(void *, CUarray, size_t, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpyAtoHAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstHost, srcArray, srcOffset, ByteCount, hStream);
}

CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY2D *, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy2DAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy, hStream);
}

CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY3D *, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy3DAsync_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy, hStream);
}

CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy,
                                     CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(const CUDA_MEMCPY3D_PEER *, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemcpy3DPeerAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pCopy, hStream);
}

CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, unsigned char, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD8_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, uc, N);
}

CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us,
                             size_t N) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, unsigned short, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD16_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, us, N);
}

CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, unsigned int, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD32_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, ui, N);
}

CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch,
                              unsigned char uc, size_t Width, size_t Height) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, size_t, unsigned char, size_t, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD2D8_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstPitch, uc, Width, Height);
}

CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch,
                               unsigned short us, size_t Width, size_t Height) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, size_t, unsigned short, size_t, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD2D16_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstPitch, us, Width, Height);
}

CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch,
                               unsigned int ui, size_t Width, size_t Height) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, size_t, unsigned int, size_t, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD2D32_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstPitch, ui, Width, Height);
}

CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc,
                                 size_t N, CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, unsigned char, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD8Async");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, uc, N, hStream);
}

CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us,
                                  size_t N, CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, unsigned short, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD16Async");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, us, N, hStream);
}

CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui,
                                  size_t N, CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, unsigned int, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD32Async");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, ui, N, hStream);
}

CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch,
                                   unsigned char uc, size_t Width,
                                   size_t Height, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, size_t, unsigned char,
                                      size_t, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD2D8Async");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstPitch, uc, Width, Height, hStream);
}

CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch,
                                    unsigned short us, size_t Width,
                                    size_t Height, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, size_t, unsigned short,
                                      size_t, size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD2D16Async");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstPitch, us, Width, Height, hStream);
}

CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch,
                                    unsigned int ui, size_t Width,
                                    size_t Height, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, size_t, unsigned int, size_t,
                                      size_t, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemsetD2D32Async");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dstDevice, dstPitch, ui, Width, Height, hStream);
}

CUresult CUDAAPI cuArrayCreate(CUarray *pHandle,
                               const CUDA_ARRAY_DESCRIPTOR *pAllocateArray) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray *, const CUDA_ARRAY_DESCRIPTOR *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuArrayCreate_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pHandle, pAllocateArray);
}

CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor,
                                      CUarray hArray) {
  using FuncPtr = CUresult(CUDAAPI *)(CUDA_ARRAY_DESCRIPTOR *, CUarray);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuArrayGetDescriptor_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pArrayDescriptor, hArray);
}

CUresult CUDAAPI cuArrayDestroy(CUarray hArray) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuArrayDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hArray);
}

CUresult CUDAAPI cuArray3DCreate(
    CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUarray *, const CUDA_ARRAY3D_DESCRIPTOR *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuArray3DCreate_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pHandle, pAllocateArray);
}

CUresult CUDAAPI cuArray3DGetDescriptor(
    CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray) {
  using FuncPtr = CUresult(CUDAAPI *)(CUDA_ARRAY3D_DESCRIPTOR *, CUarray);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuArray3DGetDescriptor_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pArrayDescriptor, hArray);
}

CUresult CUDAAPI
cuMipmappedArrayCreate(CUmipmappedArray *pHandle,
                       const CUDA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc,
                       unsigned int numMipmapLevels) {
  using FuncPtr = CUresult(CUDAAPI *)(
      CUmipmappedArray *, const CUDA_ARRAY3D_DESCRIPTOR *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMipmappedArrayCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pHandle, pMipmappedArrayDesc, numMipmapLevels);
}

CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray,
                                          CUmipmappedArray hMipmappedArray,
                                          unsigned int level) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUarray *, CUmipmappedArray, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMipmappedArrayGetLevel");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pLevelArray, hMipmappedArray, level);
}

CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmipmappedArray);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMipmappedArrayDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hMipmappedArray);
}

CUresult CUDAAPI cuPointerGetAttribute(void *data,
                                       CUpointer_attribute attribute,
                                       CUdeviceptr ptr) {
  using FuncPtr = CUresult(CUDAAPI *)(void *, CUpointer_attribute, CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuPointerGetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(data, attribute, ptr);
}

CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count,
                                    CUdevice dstDevice, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr, size_t, CUdevice, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemPrefetchAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(devPtr, count, dstDevice, hStream);
}

CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count,
                             CUmem_advise advice, CUdevice device) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr, size_t, CUmem_advise, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemAdvise");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(devPtr, count, advice, device);
}

CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize,
                                        CUmem_range_attribute attribute,
                                        CUdeviceptr devPtr, size_t count) {
  using FuncPtr = CUresult(CUDAAPI *)(void *, size_t, CUmem_range_attribute,
                                      CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemRangeGetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(data, dataSize, attribute, devPtr, count);
}

CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes,
                                         CUmem_range_attribute *attributes,
                                         size_t numAttributes,
                                         CUdeviceptr devPtr, size_t count) {
  using FuncPtr = CUresult(CUDAAPI *)(
      void **, size_t *, CUmem_range_attribute *, size_t, CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuMemRangeGetAttributes");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(data, dataSizes, attributes, numAttributes, devPtr, count);
}

CUresult CUDAAPI cuPointerSetAttribute(const void *value,
                                       CUpointer_attribute attribute,
                                       CUdeviceptr ptr) {
  using FuncPtr =
      CUresult(CUDAAPI *)(const void *, CUpointer_attribute, CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuPointerSetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(value, attribute, ptr);
}

CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes,
                                        CUpointer_attribute *attributes,
                                        void **data, CUdeviceptr ptr) {
  using FuncPtr = CUresult(CUDAAPI *)(unsigned int, CUpointer_attribute *,
                                      void **, CUdeviceptr);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuPointerGetAttributes");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(numAttributes, attributes, data, ptr);
}

CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phStream, Flags);
}

CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream,
                                            unsigned int flags, int priority) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream *, unsigned int, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamCreateWithPriority");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phStream, flags, priority);
}

CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamGetPriority");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, priority);
}

CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream, unsigned int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamGetFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, flags);
}

CUresult CUDAAPI cuStreamGetCtx(CUstream hStream, CUcontext *pctx) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream, CUcontext *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamGetCtx");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, pctx);
}

CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent,
                                   unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream, CUevent, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamWaitEvent");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, hEvent, Flags);
}

CUresult CUDAAPI cuStreamAddCallback(CUstream hStream,
                                     CUstreamCallback callback, void *userData,
                                     unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUstream, CUstreamCallback, void *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamAddCallback");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, callback, userData, flags);
}

CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr,
                                        size_t length, unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUstream, CUdeviceptr, size_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamAttachMemAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, dptr, length, flags);
}

CUresult CUDAAPI cuStreamQuery(CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamQuery");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream);
}

CUresult CUDAAPI cuStreamSynchronize(CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamSynchronize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream);
}

CUresult CUDAAPI cuStreamDestroy(CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamDestroy_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream);
}

CUresult CUDAAPI cuEventCreate(CUevent *phEvent, unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUevent *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuEventCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phEvent, Flags);
}

CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUevent, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuEventRecord");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hEvent, hStream);
}

CUresult CUDAAPI cuEventQuery(CUevent hEvent) {
  using FuncPtr = CUresult(CUDAAPI *)(CUevent);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuEventQuery");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hEvent);
}

CUresult CUDAAPI cuEventSynchronize(CUevent hEvent) {
  using FuncPtr = CUresult(CUDAAPI *)(CUevent);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuEventSynchronize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hEvent);
}

CUresult CUDAAPI cuEventDestroy(CUevent hEvent) {
  using FuncPtr = CUresult(CUDAAPI *)(CUevent);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuEventDestroy_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hEvent);
}

CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart,
                                    CUevent hEnd) {
  using FuncPtr = CUresult(CUDAAPI *)(float *, CUevent, CUevent);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuEventElapsedTime");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pMilliseconds, hStart, hEnd);
}

CUresult CUDAAPI
cuImportExternalMemory(CUexternalMemory *extMem_out,
                       const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *memHandleDesc) {
  using FuncPtr = CUresult(CUDAAPI *)(CUexternalMemory *,
                                      const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuImportExternalMemory");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(extMem_out, memHandleDesc);
}

CUresult CUDAAPI cuExternalMemoryGetMappedBuffer(
    CUdeviceptr *devPtr, CUexternalMemory extMem,
    const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *bufferDesc) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, CUexternalMemory,
                                      const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuExternalMemoryGetMappedBuffer");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(devPtr, extMem, bufferDesc);
}

CUresult CUDAAPI cuExternalMemoryGetMappedMipmappedArray(
    CUmipmappedArray *mipmap, CUexternalMemory extMem,
    const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *mipmapDesc) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUmipmappedArray *, CUexternalMemory,
                          const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuExternalMemoryGetMappedMipmappedArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(mipmap, extMem, mipmapDesc);
}

CUresult CUDAAPI cuDestroyExternalMemory(CUexternalMemory extMem) {
  using FuncPtr = CUresult(CUDAAPI *)(CUexternalMemory);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDestroyExternalMemory");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(extMem);
}

CUresult CUDAAPI cuImportExternalSemaphore(
    CUexternalSemaphore *extSem_out,
    const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *semHandleDesc) {
  using FuncPtr = CUresult(CUDAAPI *)(
      CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuImportExternalSemaphore");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(extSem_out, semHandleDesc);
}

CUresult CUDAAPI cuSignalExternalSemaphoresAsync(
    const CUexternalSemaphore *extSemArray,
    const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *paramsArray,
    unsigned int numExtSems, CUstream stream) {
  using FuncPtr = CUresult(CUDAAPI *)(
      const CUexternalSemaphore *,
      const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *, unsigned int, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuSignalExternalSemaphoresAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(extSemArray, paramsArray, numExtSems, stream);
}

CUresult CUDAAPI cuWaitExternalSemaphoresAsync(
    const CUexternalSemaphore *extSemArray,
    const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *paramsArray,
    unsigned int numExtSems, CUstream stream) {
  using FuncPtr = CUresult(CUDAAPI *)(
      const CUexternalSemaphore *, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *,
      unsigned int, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuWaitExternalSemaphoresAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(extSemArray, paramsArray, numExtSems, stream);
}

CUresult CUDAAPI cuDestroyExternalSemaphore(CUexternalSemaphore extSem) {
  using FuncPtr = CUresult(CUDAAPI *)(CUexternalSemaphore);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDestroyExternalSemaphore");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(extSem);
}

CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr,
                                     cuuint32_t value, unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamWaitValue32");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(stream, addr, value, flags);
}

CUresult CUDAAPI cuStreamWaitValue64(CUstream stream, CUdeviceptr addr,
                                     cuuint64_t value, unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamWaitValue64");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(stream, addr, value, flags);
}

CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr,
                                      cuuint32_t value, unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUstream, CUdeviceptr, cuuint32_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamWriteValue32");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(stream, addr, value, flags);
}

CUresult CUDAAPI cuStreamWriteValue64(CUstream stream, CUdeviceptr addr,
                                      cuuint64_t value, unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUstream, CUdeviceptr, cuuint64_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamWriteValue64");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(stream, addr, value, flags);
}

CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count,
                                    CUstreamBatchMemOpParams *paramArray,
                                    unsigned int flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream, unsigned int,
                                      CUstreamBatchMemOpParams *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuStreamBatchMemOp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(stream, count, paramArray, flags);
}

CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib,
                                    CUfunction hfunc) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, CUfunction_attribute, CUfunction);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuFuncGetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pi, attrib, hfunc);
}

CUresult CUDAAPI cuFuncSetAttribute(CUfunction hfunc,
                                    CUfunction_attribute attrib, int value) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, CUfunction_attribute, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuFuncSetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, attrib, value);
}

CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, CUfunc_cache);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuFuncSetCacheConfig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, config);
}

CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc,
                                          CUsharedconfig config) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, CUsharedconfig);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuFuncSetSharedMemConfig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, config);
}

CUresult CUDAAPI cuLaunchKernel(CUfunction f, unsigned int gridDimX,
                                unsigned int gridDimY, unsigned int gridDimZ,
                                unsigned int blockDimX, unsigned int blockDimY,
                                unsigned int blockDimZ,
                                unsigned int sharedMemBytes, CUstream hStream,
                                void **kernelParams, void **extra) {
  using FuncPtr = CUresult(CUDAAPI *)(
      CUfunction, unsigned int, unsigned int, unsigned int, unsigned int,
      unsigned int, unsigned int, unsigned int, CUstream, void **, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLaunchKernel");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY,
                  blockDimZ, sharedMemBytes, hStream, kernelParams, extra);
}

CUresult CUDAAPI cuLaunchCooperativeKernel(
    CUfunction f, unsigned int gridDimX, unsigned int gridDimY,
    unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY,
    unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream,
    void **kernelParams) {
  using FuncPtr = CUresult(CUDAAPI *)(
      CUfunction, unsigned int, unsigned int, unsigned int, unsigned int,
      unsigned int, unsigned int, unsigned int, CUstream, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLaunchCooperativeKernel");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY,
                  blockDimZ, sharedMemBytes, hStream, kernelParams);
}

CUresult CUDAAPI cuLaunchCooperativeKernelMultiDevice(
    CUDA_LAUNCH_PARAMS *launchParamsList, unsigned int numDevices,
    unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUDA_LAUNCH_PARAMS *, unsigned int, unsigned int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuLaunchCooperativeKernelMultiDevice");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(launchParamsList, numDevices, flags);
}

CUresult CUDAAPI cuLaunchHostFunc(CUstream hStream, CUhostFn fn,
                                  void *userData) {
  using FuncPtr = CUresult(CUDAAPI *)(CUstream, CUhostFn, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLaunchHostFunc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hStream, fn, userData);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x,
                                                       int y, int z) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, int, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuFuncSetBlockShape");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, x, y, z);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc,
                                                       unsigned int bytes) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuFuncSetSharedSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, bytes);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetSize(CUfunction hfunc,
                                                  unsigned int numbytes) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuParamSetSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, numbytes);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset,
                                               unsigned int value) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuParamSeti");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, offset, value);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset,
                                               float value) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuParamSetf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, offset, value);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset,
                                               void *ptr,
                                               unsigned int numbytes) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, void *, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuParamSetv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, offset, ptr, numbytes);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuLaunch(CUfunction f) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLaunch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(f);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width,
                                                int grid_height) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLaunchGrid");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(f, grid_width, grid_height);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchGridAsync(CUfunction f,
                                                     int grid_width,
                                                     int grid_height,
                                                     CUstream hStream) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, int, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuLaunchGridAsync");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(f, grid_width, grid_height, hStream);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc,
                                                    int texunit,
                                                    CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfunction, int, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuParamSetTexRef");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hfunc, texunit, hTexRef);
}

CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor(
    int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, CUfunction, int, size_t);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuOccupancyMaxActiveBlocksPerMultiprocessor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(numBlocks, func, blockSize, dynamicSMemSize);
}

CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
    int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize,
    unsigned int flags) {
  using FuncPtr =
      CUresult(CUDAAPI *)(int *, CUfunction, int, size_t, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>(
      "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(numBlocks, func, blockSize, dynamicSMemSize, flags);
}

CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize(
    int *minGridSize, int *blockSize, CUfunction func,
    CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize,
    int blockSizeLimit) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, int *, CUfunction,
                                      CUoccupancyB2DSize, size_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuOccupancyMaxPotentialBlockSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(minGridSize, blockSize, func, blockSizeToDynamicSMemSize,
                  dynamicSMemSize, blockSizeLimit);
}

CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags(
    int *minGridSize, int *blockSize, CUfunction func,
    CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize,
    int blockSizeLimit, unsigned int flags) {
  using FuncPtr = CUresult(CUDAAPI *)(
      int *, int *, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuOccupancyMaxPotentialBlockSizeWithFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(minGridSize, blockSize, func, blockSizeToDynamicSMemSize,
                  dynamicSMemSize, blockSizeLimit, flags);
}

CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray,
                                  unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, CUarray, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, hArray, Flags);
}

CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef,
                                           CUmipmappedArray hMipmappedArray,
                                           unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, CUmipmappedArray, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetMipmappedArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, hMipmappedArray, Flags);
}

CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef,
                                    CUdeviceptr dptr, size_t bytes) {
  using FuncPtr = CUresult(CUDAAPI *)(size_t *, CUtexref, CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetAddress_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ByteOffset, hTexRef, dptr, bytes);
}

CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef,
                                      const CUDA_ARRAY_DESCRIPTOR *desc,
                                      CUdeviceptr dptr, size_t Pitch) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, const CUDA_ARRAY_DESCRIPTOR *,
                                      CUdeviceptr, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetAddress2D_v3");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, desc, dptr, Pitch);
}

CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt,
                                   int NumPackedComponents) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, CUarray_format, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetFormat");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, fmt, NumPackedComponents);
}

CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim,
                                        CUaddress_mode am) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, int, CUaddress_mode);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetAddressMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, dim, am);
}

CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, CUfilter_mode);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetFilterMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, fm);
}

CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef,
                                             CUfilter_mode fm) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, CUfilter_mode);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetMipmapFilterMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, fm);
}

CUresult CUDAAPI cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetMipmapLevelBias");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, bias);
}

CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef,
                                             float minMipmapLevelClamp,
                                             float maxMipmapLevelClamp) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, float, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetMipmapLevelClamp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, minMipmapLevelClamp, maxMipmapLevelClamp);
}

CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef,
                                          unsigned int maxAniso) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetMaxAnisotropy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, maxAniso);
}

CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, float *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetBorderColor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, pBorderColor);
}

CUresult CUDAAPI cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefSetFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef, Flags);
}

CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUdeviceptr *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetAddress_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pdptr, hTexRef);
}

CUresult CUDAAPI cuTexRefGetArray(CUarray *phArray, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phArray, hTexRef);
}

CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray,
                                           CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmipmappedArray *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetMipmappedArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phMipmappedArray, hTexRef);
}

CUresult CUDAAPI cuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef,
                                        int dim) {
  using FuncPtr = CUresult(CUDAAPI *)(CUaddress_mode *, CUtexref, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetAddressMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pam, hTexRef, dim);
}

CUresult CUDAAPI cuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfilter_mode *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetFilterMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pfm, hTexRef);
}

CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels,
                                   CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray_format *, int *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetFormat");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pFormat, pNumChannels, hTexRef);
}

CUresult CUDAAPI cuTexRefGetMipmapFilterMode(CUfilter_mode *pfm,
                                             CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUfilter_mode *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetMipmapFilterMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pfm, hTexRef);
}

CUresult CUDAAPI cuTexRefGetMipmapLevelBias(float *pbias, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(float *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetMipmapLevelBias");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pbias, hTexRef);
}

CUresult CUDAAPI cuTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp,
                                             float *pmaxMipmapLevelClamp,
                                             CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(float *, float *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetMipmapLevelClamp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pminMipmapLevelClamp, pmaxMipmapLevelClamp, hTexRef);
}

CUresult CUDAAPI cuTexRefGetMaxAnisotropy(int *pmaxAniso, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetMaxAnisotropy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pmaxAniso, hTexRef);
}

CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(float *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetBorderColor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pBorderColor, hTexRef);
}

CUresult CUDAAPI cuTexRefGetFlags(unsigned int *pFlags, CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(unsigned int *, CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefGetFlags");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pFlags, hTexRef);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefCreate(CUtexref *pTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pTexRef);
}

__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexRefDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hTexRef);
}

CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray,
                                   unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUsurfref, CUarray, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuSurfRefSetArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(hSurfRef, hArray, Flags);
}

CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray *, CUsurfref);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuSurfRefGetArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(phArray, hSurfRef);
}

CUresult CUDAAPI
cuTexObjectCreate(CUtexObject *pTexObject, const CUDA_RESOURCE_DESC *pResDesc,
                  const CUDA_TEXTURE_DESC *pTexDesc,
                  const CUDA_RESOURCE_VIEW_DESC *pResViewDesc) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexObject *, const CUDA_RESOURCE_DESC *,
                                      const CUDA_TEXTURE_DESC *,
                                      const CUDA_RESOURCE_VIEW_DESC *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexObjectCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pTexObject, pResDesc, pTexDesc, pResViewDesc);
}

CUresult CUDAAPI cuTexObjectDestroy(CUtexObject texObject) {
  using FuncPtr = CUresult(CUDAAPI *)(CUtexObject);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexObjectDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(texObject);
}

CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc,
                                            CUtexObject texObject) {
  using FuncPtr = CUresult(CUDAAPI *)(CUDA_RESOURCE_DESC *, CUtexObject);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexObjectGetResourceDesc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pResDesc, texObject);
}

CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc,
                                           CUtexObject texObject) {
  using FuncPtr = CUresult(CUDAAPI *)(CUDA_TEXTURE_DESC *, CUtexObject);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexObjectGetTextureDesc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pTexDesc, texObject);
}

CUresult CUDAAPI cuTexObjectGetResourceViewDesc(
    CUDA_RESOURCE_VIEW_DESC *pResViewDesc, CUtexObject texObject) {
  using FuncPtr = CUresult(CUDAAPI *)(CUDA_RESOURCE_VIEW_DESC *, CUtexObject);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuTexObjectGetResourceViewDesc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pResViewDesc, texObject);
}

CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject,
                                    const CUDA_RESOURCE_DESC *pResDesc) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUsurfObject *, const CUDA_RESOURCE_DESC *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuSurfObjectCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pSurfObject, pResDesc);
}

CUresult CUDAAPI cuSurfObjectDestroy(CUsurfObject surfObject) {
  using FuncPtr = CUresult(CUDAAPI *)(CUsurfObject);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuSurfObjectDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(surfObject);
}

CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc,
                                             CUsurfObject surfObject) {
  using FuncPtr = CUresult(CUDAAPI *)(CUDA_RESOURCE_DESC *, CUsurfObject);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuSurfObjectGetResourceDesc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pResDesc, surfObject);
}

CUresult CUDAAPI cuDeviceCanAccessPeer(int *canAccessPeer, CUdevice dev,
                                       CUdevice peerDev) {
  using FuncPtr = CUresult(CUDAAPI *)(int *, CUdevice, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceCanAccessPeer");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(canAccessPeer, dev, peerDev);
}

CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext,
                                       unsigned int Flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext, unsigned int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxEnablePeerAccess");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(peerContext, Flags);
}

CUresult CUDAAPI cuCtxDisablePeerAccess(CUcontext peerContext) {
  using FuncPtr = CUresult(CUDAAPI *)(CUcontext);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuCtxDisablePeerAccess");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(peerContext);
}

CUresult CUDAAPI cuDeviceGetP2PAttribute(int *value,
                                         CUdevice_P2PAttribute attrib,
                                         CUdevice srcDevice,
                                         CUdevice dstDevice) {
  using FuncPtr =
      CUresult(CUDAAPI *)(int *, CUdevice_P2PAttribute, CUdevice, CUdevice);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuDeviceGetP2PAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(value, attrib, srcDevice, dstDevice);
}

CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource) {
  using FuncPtr = CUresult(CUDAAPI *)(CUgraphicsResource);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuGraphicsUnregisterResource");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(resource);
}

CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray(
    CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex,
    unsigned int mipLevel) {
  using FuncPtr = CUresult(CUDAAPI *)(CUarray *, CUgraphicsResource,
                                      unsigned int, unsigned int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuGraphicsSubResourceGetMappedArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pArray, resource, arrayIndex, mipLevel);
}

CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray(
    CUmipmappedArray *pMipmappedArray, CUgraphicsResource resource) {
  using FuncPtr = CUresult(CUDAAPI *)(CUmipmappedArray *, CUgraphicsResource);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuGraphicsResourceGetMappedMipmappedArray");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pMipmappedArray, resource);
}

CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(
    CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource) {
  using FuncPtr =
      CUresult(CUDAAPI *)(CUdeviceptr *, size_t *, CUgraphicsResource);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuGraphicsResourceGetMappedPointer_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(pDevPtr, pSize, resource);
}

CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource,
                                               unsigned int flags) {
  using FuncPtr = CUresult(CUDAAPI *)(CUgraphicsResource, unsigned int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cuGraphicsResourceSetMapFlags_v2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(resource, flags);
}

CUresult CUDAAPI cuGraphicsMapResources(unsigned int count,
                                        CUgraphicsResource *resources,
                                        CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(unsigned int, CUgraphicsResource *, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuGraphicsMapResources");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(count, resources, hStream);
}

CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count,
                                          CUgraphicsResource *resources,
                                          CUstream hStream) {
  using FuncPtr =
      CUresult(CUDAAPI *)(unsigned int, CUgraphicsResource *, CUstream);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuGraphicsUnmapResources");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(count, resources, hStream);
}

CUresult CUDAAPI cuGetExportTable(const void **ppExportTable,
                                  const CUuuid *pExportTableId) {
  using FuncPtr = CUresult(CUDAAPI *)(const void **, const CUuuid *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cuGetExportTable");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(ppExportTable, pExportTableId);
}

}  // extern "C"