cusparse_11_0.inc

// Auto-generated, do not edit.

#define CUSPARSE_DEPRECATED(new_func)

extern "C" {

cusparseStatus_t CUSPARSEAPI cusparseCreate(cusparseHandle_t *handle) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroy(cusparseHandle_t handle) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle);
}

cusparseStatus_t CUSPARSEAPI cusparseGetVersion(cusparseHandle_t handle,
                                                int *version) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetVersion");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, version);
}

cusparseStatus_t CUSPARSEAPI cusparseGetProperty(libraryPropertyType type,
                                                 int *value) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(libraryPropertyType, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetProperty");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(type, value);
}

const char *CUSPARSEAPI cusparseGetErrorName(cusparseStatus_t status) {
  using FuncPtr = const char *(CUSPARSEAPI *)(cusparseStatus_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetErrorName");
  if (!func_ptr) return "cusparseGetErrorName symbol not found.";
  return func_ptr(status);
}

const char *CUSPARSEAPI cusparseGetErrorString(cusparseStatus_t status) {
  using FuncPtr = const char *(CUSPARSEAPI *)(cusparseStatus_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetErrorString");
  if (!func_ptr) return "cusparseGetErrorString symbol not found.";
  return func_ptr(status);
}

cusparseStatus_t CUSPARSEAPI cusparseSetStream(cusparseHandle_t handle,
                                               cudaStream_t streamId) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cudaStream_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetStream");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, streamId);
}

cusparseStatus_t CUSPARSEAPI cusparseGetStream(cusparseHandle_t handle,
                                               cudaStream_t *streamId) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cudaStream_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetStream");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, streamId);
}

cusparseStatus_t CUSPARSEAPI
cusparseGetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t *mode) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t,
                                                  cusparsePointerMode_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetPointerMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mode);
}

cusparseStatus_t CUSPARSEAPI
cusparseSetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t mode) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, cusparsePointerMode_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetPointerMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mode);
}

cusparseStatus_t CUSPARSEAPI
cusparseCreateMatDescr(cusparseMatDescr_t *descrA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateMatDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descrA);
}

cusparseStatus_t CUSPARSEAPI
cusparseDestroyMatDescr(cusparseMatDescr_t descrA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyMatDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descrA);
}

cusparseStatus_t CUSPARSEAPI
cusparseCopyMatDescr(cusparseMatDescr_t dest, const cusparseMatDescr_t src) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t,
                                                  const cusparseMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCopyMatDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dest, src);
}

cusparseStatus_t CUSPARSEAPI cusparseSetMatType(cusparseMatDescr_t descrA,
                                                cusparseMatrixType_t type) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseMatrixType_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatType");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descrA, type);
}

cusparseMatrixType_t CUSPARSEAPI
cusparseGetMatType(const cusparseMatDescr_t descrA) {
  using FuncPtr = cusparseMatrixType_t(CUSPARSEAPI *)(const cusparseMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetMatType");
  if (!func_ptr) return cusparseMatrixType_t(-1);
  return func_ptr(descrA);
}

cusparseStatus_t CUSPARSEAPI
cusparseSetMatFillMode(cusparseMatDescr_t descrA, cusparseFillMode_t fillMode) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseFillMode_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatFillMode");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descrA, fillMode);
}

cusparseFillMode_t CUSPARSEAPI
cusparseGetMatFillMode(const cusparseMatDescr_t descrA) {
  using FuncPtr = cusparseFillMode_t(CUSPARSEAPI *)(const cusparseMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetMatFillMode");
  if (!func_ptr) return cusparseFillMode_t(-1);
  return func_ptr(descrA);
}

cusparseStatus_t CUSPARSEAPI
cusparseSetMatDiagType(cusparseMatDescr_t descrA, cusparseDiagType_t diagType) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseDiagType_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatDiagType");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descrA, diagType);
}

cusparseDiagType_t CUSPARSEAPI
cusparseGetMatDiagType(const cusparseMatDescr_t descrA) {
  using FuncPtr = cusparseDiagType_t(CUSPARSEAPI *)(const cusparseMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetMatDiagType");
  if (!func_ptr) return cusparseDiagType_t(-1);
  return func_ptr(descrA);
}

cusparseStatus_t CUSPARSEAPI cusparseSetMatIndexBase(cusparseMatDescr_t descrA,
                                                     cusparseIndexBase_t base) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseMatDescr_t, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetMatIndexBase");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descrA, base);
}

cusparseIndexBase_t CUSPARSEAPI
cusparseGetMatIndexBase(const cusparseMatDescr_t descrA) {
  using FuncPtr = cusparseIndexBase_t(CUSPARSEAPI *)(const cusparseMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetMatIndexBase");
  if (!func_ptr) return cusparseIndexBase_t(-1);
  return func_ptr(descrA);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseCreateCsrsv2Info(csrsv2Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsv2Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrsv2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrsv2Info(csrsv2Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsv2Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrsv2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateCsric02Info(csric02Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csric02Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsric02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyCsric02Info(csric02Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csric02Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsric02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateBsric02Info(bsric02Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsric02Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsric02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyBsric02Info(bsric02Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsric02Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsric02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateCsrilu02Info(csrilu02Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrilu02Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrilu02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrilu02Info(csrilu02Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrilu02Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrilu02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateBsrilu02Info(bsrilu02Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrilu02Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrilu02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrilu02Info(bsrilu02Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrilu02Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrilu02Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsv2Info(bsrsv2Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsv2Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrsv2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsv2Info(bsrsv2Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsv2Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrsv2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsm2Info(bsrsm2Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsm2Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBsrsm2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsm2Info(bsrsm2Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(bsrsm2Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyBsrsm2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateCsru2csrInfo(csru2csrInfo_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csru2csrInfo_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsru2csrInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyCsru2csrInfo(csru2csrInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csru2csrInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsru2csrInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI
cusparseCreateColorInfo(cusparseColorInfo_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateColorInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI
cusparseDestroyColorInfo(cusparseColorInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyColorInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseSetColorAlgs(cusparseColorInfo_t info,
                                                  cusparseColorAlg_t alg) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t, cusparseColorAlg_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSetColorAlgs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, alg);
}

cusparseStatus_t CUSPARSEAPI cusparseGetColorAlgs(cusparseColorInfo_t info,
                                                  cusparseColorAlg_t *alg) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseColorInfo_t,
                                                  cusparseColorAlg_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGetColorAlgs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, alg);
}

cusparseStatus_t CUSPARSEAPI cusparseCreatePruneInfo(pruneInfo_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(pruneInfo_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreatePruneInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyPruneInfo(pruneInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(pruneInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyPruneInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

CUSPARSE_DEPRECATED(cusparseAxpby)
cusparseStatus_t CUSPARSEAPI cusparseSaxpyi(cusparseHandle_t handle, int nnz,
                                            const float *alpha,
                                            const float *xVal, const int *xInd,
                                            float *y,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const float *, const float *, const int *, float *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSaxpyi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseAxpby)
cusparseStatus_t CUSPARSEAPI cusparseDaxpyi(cusparseHandle_t handle, int nnz,
                                            const double *alpha,
                                            const double *xVal, const int *xInd,
                                            double *y,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const double *, const double *, const int *,
      double *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDaxpyi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseAxpby)
cusparseStatus_t CUSPARSEAPI cusparseCaxpyi(cusparseHandle_t handle, int nnz,
                                            const cuComplex *alpha,
                                            const cuComplex *xVal,
                                            const int *xInd, cuComplex *y,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuComplex *, const cuComplex *, const int *,
      cuComplex *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCaxpyi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseAxpby)
cusparseStatus_t CUSPARSEAPI cusparseZaxpyi(cusparseHandle_t handle, int nnz,
                                            const cuDoubleComplex *alpha,
                                            const cuDoubleComplex *xVal,
                                            const int *xInd, cuDoubleComplex *y,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
      const int *, cuDoubleComplex *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZaxpyi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, alpha, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseSgthr(cusparseHandle_t handle, int nnz,
                                           const float *y, float *xVal,
                                           const int *xInd,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const float *, float *, const int *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgthr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseDgthr(cusparseHandle_t handle, int nnz,
                                           const double *y, double *xVal,
                                           const int *xInd,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const double *, double *, const int *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgthr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseCgthr(cusparseHandle_t handle, int nnz,
                                           const cuComplex *y, cuComplex *xVal,
                                           const int *xInd,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuComplex *, cuComplex *, const int *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgthr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseZgthr(cusparseHandle_t handle, int nnz,
                                           const cuDoubleComplex *y,
                                           cuDoubleComplex *xVal,
                                           const int *xInd,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuDoubleComplex *, cuDoubleComplex *,
      const int *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgthr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseSgthrz(cusparseHandle_t handle, int nnz,
                                            float *y, float *xVal,
                                            const int *xInd,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, float *, float *,
                                      const int *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgthrz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseDgthrz(cusparseHandle_t handle, int nnz,
                                            double *y, double *xVal,
                                            const int *xInd,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, double *, double *,
                                      const int *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgthrz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseCgthrz(cusparseHandle_t handle, int nnz,
                                            cuComplex *y, cuComplex *xVal,
                                            const int *xInd,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cuComplex *, cuComplex *, const int *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgthrz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseGather)
cusparseStatus_t CUSPARSEAPI cusparseZgthrz(cusparseHandle_t handle, int nnz,
                                            cuDoubleComplex *y,
                                            cuDoubleComplex *xVal,
                                            const int *xInd,
                                            cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cuDoubleComplex *, cuDoubleComplex *, const int *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgthrz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, y, xVal, xInd, idxBase);
}

CUSPARSE_DEPRECATED(cusparseScatter)
cusparseStatus_t CUSPARSEAPI cusparseSsctr(cusparseHandle_t handle, int nnz,
                                           const float *xVal, const int *xInd,
                                           float *y,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int,
                                                  const float *, const int *,
                                                  float *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSsctr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseScatter)
cusparseStatus_t CUSPARSEAPI cusparseDsctr(cusparseHandle_t handle, int nnz,
                                           const double *xVal, const int *xInd,
                                           double *y,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const double *, const int *, double *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDsctr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseScatter)
cusparseStatus_t CUSPARSEAPI cusparseCsctr(cusparseHandle_t handle, int nnz,
                                           const cuComplex *xVal,
                                           const int *xInd, cuComplex *y,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuComplex *, const int *, cuComplex *,
      cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsctr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseScatter)
cusparseStatus_t CUSPARSEAPI cusparseZsctr(cusparseHandle_t handle, int nnz,
                                           const cuDoubleComplex *xVal,
                                           const int *xInd, cuDoubleComplex *y,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuDoubleComplex *, const int *,
      cuDoubleComplex *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZsctr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, xVal, xInd, y, idxBase);
}

CUSPARSE_DEPRECATED(cusparseRot)
cusparseStatus_t CUSPARSEAPI cusparseSroti(cusparseHandle_t handle, int nnz,
                                           float *xVal, const int *xInd,
                                           float *y, const float *c,
                                           const float *s,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, float *, const int *, float *, const float *,
      const float *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSroti");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, xVal, xInd, y, c, s, idxBase);
}

CUSPARSE_DEPRECATED(cusparseRot)
cusparseStatus_t CUSPARSEAPI cusparseDroti(cusparseHandle_t handle, int nnz,
                                           double *xVal, const int *xInd,
                                           double *y, const double *c,
                                           const double *s,
                                           cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, double *, const int *, double *, const double *,
      const double *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDroti");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, nnz, xVal, xInd, y, c, s, idxBase);
}

cusparseStatus_t CUSPARSEAPI
cusparseSgemvi(cusparseHandle_t handle, cusparseOperation_t transA, int m,
               int n, const float *alpha, const float *A, int lda, int nnz,
               const float *xVal, const int *xInd, const float *beta, float *y,
               cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const float *,
      const float *, int, int, const float *, const int *, const float *,
      float *, cusparseIndexBase_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemvi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
                  idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseSgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
                          int m, int n, int nnz, int *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemvi_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, nnz, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI
cusparseDgemvi(cusparseHandle_t handle, cusparseOperation_t transA, int m,
               int n, const double *alpha, const double *A, int lda, int nnz,
               const double *xVal, const int *xInd, const double *beta,
               double *y, cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const double *,
      const double *, int, int, const double *, const int *, const double *,
      double *, cusparseIndexBase_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemvi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
                  idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseDgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
                          int m, int n, int nnz, int *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemvi_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, nnz, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCgemvi(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
    const cuComplex *alpha, const cuComplex *A, int lda, int nnz,
    const cuComplex *xVal, const int *xInd, const cuComplex *beta, cuComplex *y,
    cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
      const cuComplex *, int, int, const cuComplex *, const int *,
      const cuComplex *, cuComplex *, cusparseIndexBase_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemvi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
                  idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseCgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
                          int m, int n, int nnz, int *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemvi_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, nnz, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZgemvi(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int n,
    const cuDoubleComplex *alpha, const cuDoubleComplex *A, int lda, int nnz,
    const cuDoubleComplex *xVal, const int *xInd, const cuDoubleComplex *beta,
    cuDoubleComplex *y, cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, int, int, const cuDoubleComplex *, const int *,
      const cuDoubleComplex *, cuDoubleComplex *, cusparseIndexBase_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemvi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, alpha, A, lda, nnz, xVal, xInd, beta, y,
                  idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseZgemvi_bufferSize(cusparseHandle_t handle, cusparseOperation_t transA,
                          int m, int n, int nnz, int *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemvi_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, n, nnz, pBufferSize);
}

CUSPARSE_DEPRECATED(cusparseSpMV)
cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx_bufferSize(
    cusparseHandle_t handle, cusparseAlgMode_t alg, cusparseOperation_t transA,
    int m, int n, int nnz, const void *alpha, cudaDataType alphatype,
    const cusparseMatDescr_t descrA, const void *csrValA,
    cudaDataType csrValAtype, const int *csrRowPtrA, const int *csrColIndA,
    const void *x, cudaDataType xtype, const void *beta, cudaDataType betatype,
    void *y, cudaDataType ytype, cudaDataType executiontype,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseAlgMode_t, cusparseOperation_t, int, int, int,
      const void *, cudaDataType, const cusparseMatDescr_t, const void *,
      cudaDataType, const int *, const int *, const void *, cudaDataType,
      const void *, cudaDataType, void *, cudaDataType, cudaDataType, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrmvEx_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, alg, transA, m, n, nnz, alpha, alphatype, descrA,
                  csrValA, csrValAtype, csrRowPtrA, csrColIndA, x, xtype, beta,
                  betatype, y, ytype, executiontype, bufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpMV)
cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx(
    cusparseHandle_t handle, cusparseAlgMode_t alg, cusparseOperation_t transA,
    int m, int n, int nnz, const void *alpha, cudaDataType alphatype,
    const cusparseMatDescr_t descrA, const void *csrValA,
    cudaDataType csrValAtype, const int *csrRowPtrA, const int *csrColIndA,
    const void *x, cudaDataType xtype, const void *beta, cudaDataType betatype,
    void *y, cudaDataType ytype, cudaDataType executiontype, void *buffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseAlgMode_t, cusparseOperation_t, int, int, int,
      const void *, cudaDataType, const cusparseMatDescr_t, const void *,
      cudaDataType, const int *, const int *, const void *, cudaDataType,
      const void *, cudaDataType, void *, cudaDataType, cudaDataType, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrmvEx");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, alg, transA, m, n, nnz, alpha, alphatype, descrA,
                  csrValA, csrValAtype, csrRowPtrA, csrColIndA, x, xtype, beta,
                  betatype, y, ytype, executiontype, buffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrmv(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nb, int nnzb, const float *alpha,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    const float *x, const float *beta, float *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      const float *, const cusparseMatDescr_t, const float *, const int *,
      const int *, int, const float *, const float *, float *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
                  x, beta, y);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrmv(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nb, int nnzb, const double *alpha,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    const double *x, const double *beta, double *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      const double *, const cusparseMatDescr_t, const double *, const int *,
      const int *, int, const double *, const double *, double *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
                  x, beta, y);
}

cusparseStatus_t CUSPARSEAPI
cusparseCbsrmv(cusparseHandle_t handle, cusparseDirection_t dirA,
               cusparseOperation_t transA, int mb, int nb, int nnzb,
               const cuComplex *alpha, const cusparseMatDescr_t descrA,
               const cuComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
               const int *bsrSortedColIndA, int blockDim, const cuComplex *x,
               const cuComplex *beta, cuComplex *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, int, const cuComplex *, const cuComplex *,
      cuComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
                  x, beta, y);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrmv(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nb, int nnzb,
    const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
    const int *bsrSortedColIndA, int blockDim, const cuDoubleComplex *x,
    const cuDoubleComplex *beta, cuDoubleComplex *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      const cuDoubleComplex *, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int,
      const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockDim,
                  x, beta, y);
}

cusparseStatus_t CUSPARSEAPI
cusparseSbsrxmv(cusparseHandle_t handle, cusparseDirection_t dirA,
                cusparseOperation_t transA, int sizeOfMask, int mb, int nb,
                int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
                const float *bsrSortedValA, const int *bsrSortedMaskPtrA,
                const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
                const int *bsrSortedColIndA, int blockDim, const float *x,
                const float *beta, float *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      int, const float *, const cusparseMatDescr_t, const float *, const int *,
      const int *, const int *, const int *, int, const float *, const float *,
      float *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrxmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
                  bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
}

cusparseStatus_t CUSPARSEAPI
cusparseDbsrxmv(cusparseHandle_t handle, cusparseDirection_t dirA,
                cusparseOperation_t transA, int sizeOfMask, int mb, int nb,
                int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
                const double *bsrSortedValA, const int *bsrSortedMaskPtrA,
                const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
                const int *bsrSortedColIndA, int blockDim, const double *x,
                const double *beta, double *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      int, const double *, const cusparseMatDescr_t, const double *,
      const int *, const int *, const int *, const int *, int, const double *,
      const double *, double *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrxmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
                  bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrxmv(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int sizeOfMask, int mb, int nb, int nnzb,
    const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *bsrSortedValA, const int *bsrSortedMaskPtrA,
    const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
    const int *bsrSortedColIndA, int blockDim, const cuComplex *x,
    const cuComplex *beta, cuComplex *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, const int *, const int *, int,
      const cuComplex *, const cuComplex *, cuComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrxmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
                  bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrxmv(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int sizeOfMask, int mb, int nb, int nnzb,
    const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *bsrSortedValA, const int *bsrSortedMaskPtrA,
    const int *bsrSortedRowPtrA, const int *bsrSortedEndPtrA,
    const int *bsrSortedColIndA, int blockDim, const cuDoubleComplex *x,
    const cuDoubleComplex *beta, cuDoubleComplex *y) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int, int,
      int, const cuDoubleComplex *, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, const int *,
      const int *, int, const cuDoubleComplex *, const cuDoubleComplex *,
      cuDoubleComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrxmv");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, sizeOfMask, mb, nb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedMaskPtrA, bsrSortedRowPtrA,
                  bsrSortedEndPtrA, bsrSortedColIndA, blockDim, x, beta, y);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseXcsrsv2_zeroPivot(cusparseHandle_t handle,
                                                       csrsv2Info_t info,
                                                       int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsv2_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, csrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, csrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, csrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, csrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, csrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, csrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, csrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, csrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, pBufferSize);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_analysis(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, csrsv2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_analysis(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, csrsv2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_analysis(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, csrsv2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_analysis(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, csrsv2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, csrsv2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_solve(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const float *alpha, const cusparseMatDescr_t descrA,
    const float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrsv2Info_t info, const float *f, float *x,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const float *,
      const cusparseMatDescr_t, const float *, const int *, const int *,
      csrsv2Info_t, const float *, float *, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
                  pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_solve(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const double *alpha, const cusparseMatDescr_t descrA,
    const double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrsv2Info_t info, const double *f, double *x,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const double *,
      const cusparseMatDescr_t, const double *, const int *, const int *,
      csrsv2Info_t, const double *, double *, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
                  pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_solve(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrsv2Info_t info, const cuComplex *f,
    cuComplex *x, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cuComplex *,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      csrsv2Info_t, const cuComplex *, cuComplex *, cusparseSolvePolicy_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
                  pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpSV)
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_solve(
    cusparseHandle_t handle, cusparseOperation_t transA, int m, int nnz,
    const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrsv2Info_t info, const cuDoubleComplex *f,
    cuDoubleComplex *x, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, csrsv2Info_t, const cuDoubleComplex *, cuDoubleComplex *,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, transA, m, nnz, alpha, descrA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXbsrsv2_zeroPivot(cusparseHandle_t handle,
                                                       bsrsv2Info_t info,
                                                       int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrsv2_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, float *, const int *, const int *, int,
      bsrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, double *, const int *, const int *, int,
      bsrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, cuComplex *, const int *, const int *, int,
      bsrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, cuDoubleComplex *, const int *, const int *,
      int, bsrsv2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
    bsrsv2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, float *, const int *, const int *, int,
      bsrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
                  pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
    bsrsv2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, double *, const int *, const int *, int,
      bsrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
                  pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
    bsrsv2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, cuComplex *, const int *, const int *, int,
      bsrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
                  pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockSize,
    bsrsv2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, cuDoubleComplex *, const int *, const int *,
      int, bsrsv2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockSize, info,
                  pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, const float *, const int *, const int *, int,
      bsrsv2Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, const double *, const int *, const int *, int,
      bsrsv2Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      int, bsrsv2Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, int, bsrsv2Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, policy,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb, const float *alpha,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, const float *f, float *x, cusparseSolvePolicy_t policy,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const float *, const cusparseMatDescr_t, const float *, const int *,
      const int *, int, bsrsv2Info_t, const float *, float *,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
                  policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb, const double *alpha,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, const double *f, double *x, cusparseSolvePolicy_t policy,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const double *, const cusparseMatDescr_t, const double *, const int *,
      const int *, int, bsrsv2Info_t, const double *, double *,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
                  policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb, const cuComplex *alpha,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, const cuComplex *f, cuComplex *x,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, int, bsrsv2Info_t, const cuComplex *,
      cuComplex *, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
                  policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, int mb, int nnzb, const cuDoubleComplex *alpha,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    bsrsv2Info_t info, const cuDoubleComplex *f, cuDoubleComplex *x,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t, int, int,
      const cuDoubleComplex *, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, bsrsv2Info_t,
      const cuDoubleComplex *, cuDoubleComplex *, cusparseSolvePolicy_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsv2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, mb, nnzb, alpha, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, blockDim, info, f, x,
                  policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrmm(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int kb, int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
    const float *bsrSortedValA, const int *bsrSortedRowPtrA,
    const int *bsrSortedColIndA, const int blockSize, const float *B,
    const int ldb, const float *beta, float *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, int, const float *,
      const cusparseMatDescr_t, const float *, const int *, const int *,
      const int, const float *, const int, const float *, float *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrmm");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
                  B, ldb, beta, C, ldc);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrmm(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int kb, int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
    const double *bsrSortedValA, const int *bsrSortedRowPtrA,
    const int *bsrSortedColIndA, const int blockSize, const double *B,
    const int ldb, const double *beta, double *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, int, const double *,
      const cusparseMatDescr_t, const double *, const int *, const int *,
      const int, const double *, const int, const double *, double *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrmm");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
                  B, ldb, beta, C, ldc);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrmm(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int kb, int nnzb, const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *bsrSortedValA, const int *bsrSortedRowPtrA,
    const int *bsrSortedColIndA, const int blockSize, const cuComplex *B,
    const int ldb, const cuComplex *beta, cuComplex *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, int, const cuComplex *,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      const int, const cuComplex *, const int, const cuComplex *, cuComplex *,
      int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrmm");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
                  B, ldb, beta, C, ldc);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrmm(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int kb, int nnzb, const cuDoubleComplex *alpha,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA,
    const int blockSize, const cuDoubleComplex *B, const int ldb,
    const cuDoubleComplex *beta, cuDoubleComplex *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, const int, const cuDoubleComplex *, const int,
      const cuDoubleComplex *, cuDoubleComplex *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrmm");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, kb, nnzb, alpha, descrA,
                  bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, blockSize,
                  B, ldb, beta, C, ldc);
}

CUSPARSE_DEPRECATED(cusparseSpMM)
cusparseStatus_t CUSPARSEAPI cusparseSgemmi(
    cusparseHandle_t handle, int m, int n, int k, int nnz, const float *alpha,
    const float *A, int lda, const float *cscValB, const int *cscColPtrB,
    const int *cscRowIndB, const float *beta, float *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, int, const float *, const float *, int,
      const float *, const int *, const int *, const float *, float *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgemmi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
                  cscRowIndB, beta, C, ldc);
}

CUSPARSE_DEPRECATED(cusparseSpMM)
cusparseStatus_t CUSPARSEAPI cusparseDgemmi(
    cusparseHandle_t handle, int m, int n, int k, int nnz, const double *alpha,
    const double *A, int lda, const double *cscValB, const int *cscColPtrB,
    const int *cscRowIndB, const double *beta, double *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, int, const double *, const double *, int,
      const double *, const int *, const int *, const double *, double *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgemmi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
                  cscRowIndB, beta, C, ldc);
}

CUSPARSE_DEPRECATED(cusparseSpMM)
cusparseStatus_t CUSPARSEAPI cusparseCgemmi(
    cusparseHandle_t handle, int m, int n, int k, int nnz,
    const cuComplex *alpha, const cuComplex *A, int lda,
    const cuComplex *cscValB, const int *cscColPtrB, const int *cscRowIndB,
    const cuComplex *beta, cuComplex *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, int, const cuComplex *,
      const cuComplex *, int, const cuComplex *, const int *, const int *,
      const cuComplex *, cuComplex *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgemmi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
                  cscRowIndB, beta, C, ldc);
}

CUSPARSE_DEPRECATED(cusparseSpMM)
cusparseStatus_t CUSPARSEAPI
cusparseZgemmi(cusparseHandle_t handle, int m, int n, int k, int nnz,
               const cuDoubleComplex *alpha, const cuDoubleComplex *A, int lda,
               const cuDoubleComplex *cscValB, const int *cscColPtrB,
               const int *cscRowIndB, const cuDoubleComplex *beta,
               cuDoubleComplex *C, int ldc) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, int, const cuDoubleComplex *, const int *,
      const int *, const cuDoubleComplex *, cuDoubleComplex *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgemmi");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, nnz, alpha, A, lda, cscValB, cscColPtrB,
                  cscRowIndB, beta, C, ldc);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateCsrsm2Info(csrsm2Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsm2Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrsm2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrsm2Info(csrsm2Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrsm2Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrsm2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsrsm2_zeroPivot(cusparseHandle_t handle,
                                                       csrsm2Info_t info,
                                                       int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrsm2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsm2_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrsm2_bufferSizeExt(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz, const float *alpha,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *B,
    int ldb, csrsm2Info_t info, cusparseSolvePolicy_t policy,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const float *, const cusparseMatDescr_t, const float *, const int *,
      const int *, const float *, int, csrsm2Info_t, cusparseSolvePolicy_t,
      size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrsm2_bufferSizeExt(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz, const double *alpha,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, const double *B,
    int ldb, csrsm2Info_t info, cusparseSolvePolicy_t policy,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const double *, const cusparseMatDescr_t, const double *,
      const int *, const int *, const double *, int, csrsm2Info_t,
      cusparseSolvePolicy_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrsm2_bufferSizeExt(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz,
    const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cuComplex *B, int ldb, csrsm2Info_t info,
    cusparseSolvePolicy_t policy, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, const cuComplex *, int, csrsm2Info_t,
      cusparseSolvePolicy_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrsm2_bufferSizeExt(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz,
    const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
    csrsm2Info_t info, cusparseSolvePolicy_t policy, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const cuDoubleComplex *, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *,
      const cuDoubleComplex *, int, csrsm2Info_t, cusparseSolvePolicy_t,
      size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrsm2_analysis(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz, const float *alpha,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *B,
    int ldb, csrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const float *, const cusparseMatDescr_t, const float *, const int *,
      const int *, const float *, int, csrsm2Info_t, cusparseSolvePolicy_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrsm2_analysis(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz, const double *alpha,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, const double *B,
    int ldb, csrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const double *, const cusparseMatDescr_t, const double *,
      const int *, const int *, const double *, int, csrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrsm2_analysis(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz,
    const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cuComplex *B, int ldb, csrsm2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, const cuComplex *, int, csrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrsm2_analysis(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz,
    const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cuDoubleComplex *B, int ldb,
    csrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const cuDoubleComplex *, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *,
      const cuDoubleComplex *, int, csrsm2Info_t, cusparseSolvePolicy_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrsm2_solve(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz, const float *alpha,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float *B, int ldb,
    csrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const float *, const cusparseMatDescr_t, const float *, const int *,
      const int *, float *, int, csrsm2Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrsm2_solve(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz, const double *alpha,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, double *B,
    int ldb, csrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const double *, const cusparseMatDescr_t, const double *,
      const int *, const int *, double *, int, csrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrsm2_solve(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz,
    const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, cuComplex *B, int ldb, csrsm2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const cuComplex *, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, cuComplex *, int, csrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrsm2_solve(
    cusparseHandle_t handle, int algo, cusparseOperation_t transA,
    cusparseOperation_t transB, int m, int nrhs, int nnz,
    const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, cuDoubleComplex *B, int ldb, csrsm2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, cusparseOperation_t, cusparseOperation_t, int, int,
      int, const cuDoubleComplex *, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *, int,
      csrsm2Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, transA, transB, m, nrhs, nnz, alpha, descrA,
                  csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, ldb,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXbsrsm2_zeroPivot(cusparseHandle_t handle,
                                                       bsrsm2Info_t info,
                                                       int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrsm2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrsm2_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, int, bsrsm2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, int, bsrsm2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, int, bsrsm2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, int, bsrsm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, int, bsrsm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, int, bsrsm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transB, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transB, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, const float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, bsrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, const double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, bsrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA, const cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrsm2Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int, bsrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, bsrsm2Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const float *alpha, const cusparseMatDescr_t descrA,
    const float *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
    const float *B, int ldb, float *X, int ldx, cusparseSolvePolicy_t policy,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const float *,
      const cusparseMatDescr_t, const float *, const int *, const int *, int,
      bsrsm2Info_t, const float *, int, float *, int, cusparseSolvePolicy_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, B, ldb, X, ldx, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const double *alpha, const cusparseMatDescr_t descrA,
    const double *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
    const double *B, int ldb, double *X, int ldx, cusparseSolvePolicy_t policy,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const double *,
      const cusparseMatDescr_t, const double *, const int *, const int *, int,
      bsrsm2Info_t, const double *, int, double *, int, cusparseSolvePolicy_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, B, ldb, X, ldx, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cuComplex *alpha, const cusparseMatDescr_t descrA,
    const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
    const cuComplex *B, int ldb, cuComplex *X, int ldx,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cuComplex *,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      int, bsrsm2Info_t, const cuComplex *, int, cuComplex *, int,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, B, ldb, X, ldx, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_solve(
    cusparseHandle_t handle, cusparseDirection_t dirA,
    cusparseOperation_t transA, cusparseOperation_t transXY, int mb, int n,
    int nnzb, const cuDoubleComplex *alpha, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int blockSize, bsrsm2Info_t info,
    const cuDoubleComplex *B, int ldb, cuDoubleComplex *X, int ldx,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, cusparseOperation_t,
      cusparseOperation_t, int, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, int, bsrsm2Info_t, const cuDoubleComplex *, int,
      cuDoubleComplex *, int, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrsm2_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, transA, transXY, mb, n, nnzb, alpha, descrA,
                  bsrSortedVal, bsrSortedRowPtr, bsrSortedColInd, blockSize,
                  info, B, ldb, X, ldx, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_numericBoost(
    cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
    float *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, csrilu02Info_t, int, double *, float *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_numericBoost(
    cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
    double *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, csrilu02Info_t, int, double *, double *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_numericBoost(
    cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
    cuComplex *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, csrilu02Info_t, int, double *, cuComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_numericBoost(
    cusparseHandle_t handle, csrilu02Info_t info, int enable_boost, double *tol,
    cuDoubleComplex *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, csrilu02Info_t, int, double *, cuDoubleComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsrilu02_zeroPivot(
    cusparseHandle_t handle, csrilu02Info_t info, int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrilu02_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, csrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, csrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, csrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
      const int *, const int *, csrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    float *csrSortedVal, const int *csrSortedRowPtr, const int *csrSortedColInd,
    csrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, csrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    double *csrSortedVal, const int *csrSortedRowPtr,
    const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, csrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuComplex *csrSortedVal, const int *csrSortedRowPtr,
    const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, csrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
    const int *csrSortedColInd, csrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
      const int *, const int *, csrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, csrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrilu02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    float *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    double *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuComplex *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuDoubleComplex *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csrilu02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
      const int *, const int *, csrilu02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_numericBoost(
    cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
    float *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, bsrilu02Info_t, int, double *, float *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_numericBoost(
    cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
    double *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, bsrilu02Info_t, int, double *, double *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_numericBoost(
    cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
    cuComplex *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, bsrilu02Info_t, int, double *, cuComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_numericBoost(
    cusparseHandle_t handle, bsrilu02Info_t info, int enable_boost, double *tol,
    cuDoubleComplex *boost_val) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, bsrilu02Info_t, int, double *, cuDoubleComplex *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_numericBoost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, enable_boost, tol, boost_val);
}

cusparseStatus_t CUSPARSEAPI cusparseXbsrilu02_zeroPivot(
    cusparseHandle_t handle, bsrilu02Info_t info, int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsrilu02_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsrilu02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsrilu02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
      size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsrilu02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsrilu02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsrilu02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsric02_zeroPivot(cusparseHandle_t handle,
                                                        csric02Info_t info,
                                                        int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, csric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsric02_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, csric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, csric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, csric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSize(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
      const int *, const int *, csric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    float *csrSortedVal, const int *csrSortedRowPtr, const int *csrSortedColInd,
    csric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, csric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    double *csrSortedVal, const int *csrSortedRowPtr,
    const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, csric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuComplex *csrSortedVal, const int *csrSortedRowPtr,
    const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, csric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSizeExt(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuDoubleComplex *csrSortedVal, const int *csrSortedRowPtr,
    const int *csrSortedColInd, csric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
      const int *, const int *, csric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedVal, csrSortedRowPtr,
                  csrSortedColInd, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseScsric02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsric02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsric02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsric02_analysis(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, csric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsric02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    float *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, float *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsric02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    double *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, double *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsric02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuComplex *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsric02(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    cuDoubleComplex *csrSortedValA_valM, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, csric02Info_t info,
    cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, cuDoubleComplex *,
      const int *, const int *, csric02Info_t, cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA,
                  csrSortedColIndA, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXbsric02_zeroPivot(cusparseHandle_t handle,
                                                        bsric02Info_t info,
                                                        int *position) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, bsric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXbsric02_zeroPivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, position);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsric02Info_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsric02Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockSize,
    bsric02Info_t info, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
      size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockSize, info, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsric02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pInputBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsric02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pInputBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsric02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pInputBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsric02_analysis(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pInputBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pInputBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsric02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, float *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      float *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsric02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, double *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      double *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsric02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuComplex *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsric02(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nnzb,
    const cusparseMatDescr_t descrA, cuDoubleComplex *bsrSortedVal,
    const int *bsrSortedRowPtr, const int *bsrSortedColInd, int blockDim,
    bsric02Info_t info, cusparseSolvePolicy_t policy, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, const int *, int, bsric02Info_t,
      cusparseSolvePolicy_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsric02");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nnzb, descrA, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, blockDim, info, policy, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
    const float *du, const float *B, int ldb, size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const float *, const float *,
      const float *, int, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
    const double *du, const double *B, int ldb, size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const double *,
      const double *, const double *, int, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const cuComplex *dl,
    const cuComplex *d, const cuComplex *du, const cuComplex *B, int ldb,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
      const cuComplex *, const cuComplex *, int, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
    const cuDoubleComplex *d, const cuDoubleComplex *du,
    const cuDoubleComplex *B, int ldb, size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
      int, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsv2(cusparseHandle_t handle, int m,
                                            int n, const float *dl,
                                            const float *d, const float *du,
                                            float *B, int ldb, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const float *, const float *,
      float *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsv2(cusparseHandle_t handle, int m,
                                            int n, const double *dl,
                                            const double *d, const double *du,
                                            double *B, int ldb, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const double *,
      const double *, double *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsv2(cusparseHandle_t handle, int m,
                                            int n, const cuComplex *dl,
                                            const cuComplex *d,
                                            const cuComplex *du, cuComplex *B,
                                            int ldb, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
      const cuComplex *, cuComplex *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsv2(cusparseHandle_t handle, int m,
                                            int n, const cuDoubleComplex *dl,
                                            const cuDoubleComplex *d,
                                            const cuDoubleComplex *du,
                                            cuDoubleComplex *B, int ldb,
                                            void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
    const float *du, const float *B, int ldb, size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const float *, const float *,
      const float *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSgtsv2_nopivot_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
    const double *du, const double *B, int ldb, size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const double *,
      const double *, const double *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDgtsv2_nopivot_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const cuComplex *dl,
    const cuComplex *d, const cuComplex *du, const cuComplex *B, int ldb,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
      const cuComplex *, const cuComplex *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCgtsv2_nopivot_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
    const cuDoubleComplex *d, const cuDoubleComplex *du,
    const cuDoubleComplex *B, int ldb, size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
      int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZgtsv2_nopivot_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot(
    cusparseHandle_t handle, int m, int n, const float *dl, const float *d,
    const float *du, float *B, int ldb, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const float *, const float *,
      float *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2_nopivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot(
    cusparseHandle_t handle, int m, int n, const double *dl, const double *d,
    const double *du, double *B, int ldb, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const double *,
      const double *, double *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2_nopivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot(
    cusparseHandle_t handle, int m, int n, const cuComplex *dl,
    const cuComplex *d, const cuComplex *du, cuComplex *B, int ldb,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
      const cuComplex *, cuComplex *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2_nopivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot(
    cusparseHandle_t handle, int m, int n, const cuDoubleComplex *dl,
    const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *B,
    int ldb, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, cuDoubleComplex *, int,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2_nopivot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, dl, d, du, B, ldb, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch_bufferSizeExt(
    cusparseHandle_t handle, int m, const float *dl, const float *d,
    const float *du, const float *x, int batchCount, int batchStride,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const float *, const float *, const float *,
      const float *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSgtsv2StridedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
                  bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsv2StridedBatch_bufferSizeExt(
    cusparseHandle_t handle, int m, const double *dl, const double *d,
    const double *du, const double *x, int batchCount, int batchStride,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const double *, const double *, const double *,
      const double *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDgtsv2StridedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
                  bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch_bufferSizeExt(
    cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
    const cuComplex *du, const cuComplex *x, int batchCount, int batchStride,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuComplex *, const cuComplex *,
      const cuComplex *, const cuComplex *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCgtsv2StridedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
                  bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch_bufferSizeExt(
    cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
    const cuDoubleComplex *d, const cuDoubleComplex *du,
    const cuDoubleComplex *x, int batchCount, int batchStride,
    size_t *bufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZgtsv2StridedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride,
                  bufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch(
    cusparseHandle_t handle, int m, const float *dl, const float *d,
    const float *du, float *x, int batchCount, int batchStride, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const float *, const float *, const float *,
      float *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsv2StridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseDgtsv2StridedBatch(cusparseHandle_t handle, int m, const double *dl,
                           const double *d, const double *du, double *x,
                           int batchCount, int batchStride, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const double *, const double *, const double *,
      double *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsv2StridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch(
    cusparseHandle_t handle, int m, const cuComplex *dl, const cuComplex *d,
    const cuComplex *du, cuComplex *x, int batchCount, int batchStride,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuComplex *, const cuComplex *,
      const cuComplex *, cuComplex *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsv2StridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch(
    cusparseHandle_t handle, int m, const cuDoubleComplex *dl,
    const cuDoubleComplex *d, const cuDoubleComplex *du, cuDoubleComplex *x,
    int batchCount, int batchStride, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cuDoubleComplex *, const cuDoubleComplex *,
      const cuDoubleComplex *, cuDoubleComplex *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsv2StridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, dl, d, du, x, batchCount, batchStride, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const float *dl, const float *d,
    const float *du, const float *x, int batchCount,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const float *, const float *,
      const float *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSgtsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const double *dl, const double *d,
    const double *du, const double *x, int batchCount,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const double *,
      const double *, const double *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDgtsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const cuComplex *dl,
    const cuComplex *d, const cuComplex *du, const cuComplex *x, int batchCount,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
      const cuComplex *, const cuComplex *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCgtsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const cuDoubleComplex *dl,
    const cuDoubleComplex *d, const cuDoubleComplex *du,
    const cuDoubleComplex *x, int batchCount, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
      int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZgtsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgtsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, float *dl, float *d, float *du,
    float *x, int batchCount, void *pBuffer) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int, float *,
                                      float *, float *, float *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgtsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDgtsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, double *dl, double *d, double *du,
    double *x, int batchCount, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int,
                                                  double *, double *, double *,
                                                  double *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgtsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgtsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, cuComplex *dl, cuComplex *d,
    cuComplex *du, cuComplex *x, int batchCount, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, cuComplex *, cuComplex *, cuComplex *,
      cuComplex *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgtsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgtsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, cuDoubleComplex *dl,
    cuDoubleComplex *d, cuDoubleComplex *du, cuDoubleComplex *x, int batchCount,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, cuDoubleComplex *, cuDoubleComplex *,
      cuDoubleComplex *, cuDoubleComplex *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgtsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, dl, d, du, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgpsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const float *ds, const float *dl,
    const float *d, const float *du, const float *dw, const float *x,
    int batchCount, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const float *, const float *,
      const float *, const float *, const float *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSgpsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgpsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const double *ds,
    const double *dl, const double *d, const double *du, const double *dw,
    const double *x, int batchCount, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const double *,
      const double *, const double *, const double *, const double *, int,
      size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDgpsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgpsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const cuComplex *ds,
    const cuComplex *dl, const cuComplex *d, const cuComplex *du,
    const cuComplex *dw, const cuComplex *x, int batchCount,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cuComplex *,
      const cuComplex *, const cuComplex *, const cuComplex *,
      const cuComplex *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCgpsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgpsvInterleavedBatch_bufferSizeExt(
    cusparseHandle_t handle, int algo, int m, const cuDoubleComplex *ds,
    const cuDoubleComplex *dl, const cuDoubleComplex *d,
    const cuDoubleComplex *du, const cuDoubleComplex *dw,
    const cuDoubleComplex *x, int batchCount, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, const cuDoubleComplex *,
      const cuDoubleComplex *, const cuDoubleComplex *, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZgpsvInterleavedBatch_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgpsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, float *ds, float *dl, float *d,
    float *du, float *dw, float *x, int batchCount, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, float *, float *, float *, float *, float *,
      float *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgpsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDgpsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, double *ds, double *dl, double *d,
    double *du, double *dw, double *x, int batchCount, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, double *, double *, double *, double *,
      double *, double *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgpsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgpsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, cuComplex *ds, cuComplex *dl,
    cuComplex *d, cuComplex *du, cuComplex *dw, cuComplex *x, int batchCount,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, cuComplex *, cuComplex *, cuComplex *,
      cuComplex *, cuComplex *, cuComplex *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgpsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgpsvInterleavedBatch(
    cusparseHandle_t handle, int algo, int m, cuDoubleComplex *ds,
    cuDoubleComplex *dl, cuDoubleComplex *d, cuDoubleComplex *du,
    cuDoubleComplex *dw, cuDoubleComplex *x, int batchCount, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, cuDoubleComplex *, cuDoubleComplex *,
      cuDoubleComplex *, cuDoubleComplex *, cuDoubleComplex *,
      cuDoubleComplex *, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgpsvInterleavedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, algo, m, ds, dl, d, du, dw, x, batchCount, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseCreateCsrgemm2Info(csrgemm2Info_t *info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrgemm2Info_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsrgemm2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrgemm2Info(csrgemm2Info_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(csrgemm2Info_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyCsrgemm2Info");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int k, const float *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB, const float *beta,
    const cusparseMatDescr_t descrD, int nnzD, const int *csrSortedRowPtrD,
    const int *csrSortedColIndD, csrgemm2Info_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const float *, const cusparseMatDescr_t,
      int, const int *, const int *, const cusparseMatDescr_t, int, const int *,
      const int *, const float *, const cusparseMatDescr_t, int, const int *,
      const int *, csrgemm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
                  csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
                  csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
                  csrSortedColIndD, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int k, const double *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const double *beta, const cusparseMatDescr_t descrD, int nnzD,
    const int *csrSortedRowPtrD, const int *csrSortedColIndD,
    csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const double *, const cusparseMatDescr_t,
      int, const int *, const int *, const cusparseMatDescr_t, int, const int *,
      const int *, const double *, const cusparseMatDescr_t, int, const int *,
      const int *, csrgemm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
                  csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
                  csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
                  csrSortedColIndD, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int k, const cuComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const cuComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
    const int *csrSortedRowPtrD, const int *csrSortedColIndD,
    csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuComplex *,
      const cusparseMatDescr_t, int, const int *, const int *,
      const cusparseMatDescr_t, int, const int *, const int *,
      const cuComplex *, const cusparseMatDescr_t, int, const int *,
      const int *, csrgemm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
                  csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
                  csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
                  csrSortedColIndD, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int k, const cuDoubleComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const cuDoubleComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
    const int *csrSortedRowPtrD, const int *csrSortedColIndD,
    csrgemm2Info_t info, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, int, const int *, const int *,
      const cusparseMatDescr_t, int, const int *, const int *,
      const cuDoubleComplex *, const cusparseMatDescr_t, int, const int *,
      const int *, csrgemm2Info_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedRowPtrA,
                  csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
                  csrSortedColIndB, beta, descrD, nnzD, csrSortedRowPtrD,
                  csrSortedColIndD, info, pBufferSizeInBytes);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseXcsrgemm2Nnz(
    cusparseHandle_t handle, int m, int n, int k,
    const cusparseMatDescr_t descrA, int nnzA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const cusparseMatDescr_t descrD, int nnzD, const int *csrSortedRowPtrD,
    const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
    int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, const csrgemm2Info_t info,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, int,
      const int *, const int *, const cusparseMatDescr_t, int, const int *,
      const int *, const cusparseMatDescr_t, int, const int *, const int *,
      const cusparseMatDescr_t, int *, int *, const csrgemm2Info_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgemm2Nnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, descrA, nnzA, csrSortedRowPtrA,
                  csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
                  csrSortedColIndB, descrD, nnzD, csrSortedRowPtrD,
                  csrSortedColIndD, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, info, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2(
    cusparseHandle_t handle, int m, int n, int k, const float *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB, const float *beta,
    const cusparseMatDescr_t descrD, int nnzD, const float *csrSortedValD,
    const int *csrSortedRowPtrD, const int *csrSortedColIndD,
    const cusparseMatDescr_t descrC, float *csrSortedValC,
    const int *csrSortedRowPtrC, int *csrSortedColIndC,
    const csrgemm2Info_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const float *, const cusparseMatDescr_t,
      int, const float *, const int *, const int *, const cusparseMatDescr_t,
      int, const float *, const int *, const int *, const float *,
      const cusparseMatDescr_t, int, const float *, const int *, const int *,
      const cusparseMatDescr_t, float *, const int *, int *,
      const csrgemm2Info_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgemm2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
                  descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
                  csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
                  csrSortedColIndC, info, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2(
    cusparseHandle_t handle, int m, int n, int k, const double *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrB, int nnzB, const double *csrSortedValB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const double *beta, const cusparseMatDescr_t descrD, int nnzD,
    const double *csrSortedValD, const int *csrSortedRowPtrD,
    const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
    double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
    const csrgemm2Info_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const double *, const cusparseMatDescr_t,
      int, const double *, const int *, const int *, const cusparseMatDescr_t,
      int, const double *, const int *, const int *, const double *,
      const cusparseMatDescr_t, int, const double *, const int *, const int *,
      const cusparseMatDescr_t, double *, const int *, int *,
      const csrgemm2Info_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgemm2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
                  descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
                  csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
                  csrSortedColIndC, info, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2(
    cusparseHandle_t handle, int m, int n, int k, const cuComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrB, int nnzB, const cuComplex *csrSortedValB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const cuComplex *beta, const cusparseMatDescr_t descrD, int nnzD,
    const cuComplex *csrSortedValD, const int *csrSortedRowPtrD,
    const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
    cuComplex *csrSortedValC, const int *csrSortedRowPtrC,
    int *csrSortedColIndC, const csrgemm2Info_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuComplex *,
      const cusparseMatDescr_t, int, const cuComplex *, const int *,
      const int *, const cusparseMatDescr_t, int, const cuComplex *,
      const int *, const int *, const cuComplex *, const cusparseMatDescr_t,
      int, const cuComplex *, const int *, const int *,
      const cusparseMatDescr_t, cuComplex *, const int *, int *,
      const csrgemm2Info_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgemm2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
                  descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
                  csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
                  csrSortedColIndC, info, pBuffer);
}

CUSPARSE_DEPRECATED(cusparseSpGEMM)
cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2(
    cusparseHandle_t handle, int m, int n, int k, const cuDoubleComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrB, int nnzB,
    const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cuDoubleComplex *beta,
    const cusparseMatDescr_t descrD, int nnzD,
    const cuDoubleComplex *csrSortedValD, const int *csrSortedRowPtrD,
    const int *csrSortedColIndD, const cusparseMatDescr_t descrC,
    cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
    int *csrSortedColIndC, const csrgemm2Info_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
      const int *, const cusparseMatDescr_t, int, const cuDoubleComplex *,
      const int *, const int *, const cuDoubleComplex *,
      const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
      const int *, const cusparseMatDescr_t, cuDoubleComplex *, const int *,
      int *, const csrgemm2Info_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgemm2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, beta,
                  descrD, nnzD, csrSortedValD, csrSortedRowPtrD,
                  csrSortedColIndD, descrC, csrSortedValC, csrSortedRowPtrC,
                  csrSortedColIndC, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrgeam2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const float *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *beta,
    const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const cusparseMatDescr_t descrC, const float *csrSortedValC,
    const int *csrSortedRowPtrC, const int *csrSortedColIndC,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const cusparseMatDescr_t, int,
      const float *, const int *, const int *, const float *,
      const cusparseMatDescr_t, int, const float *, const int *, const int *,
      const cusparseMatDescr_t, const float *, const int *, const int *,
      size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgeam2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const double *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const double *beta, const cusparseMatDescr_t descrB, int nnzB,
    const double *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    const double *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const cusparseMatDescr_t, int,
      const double *, const int *, const int *, const double *,
      const cusparseMatDescr_t, int, const double *, const int *, const int *,
      const cusparseMatDescr_t, const double *, const int *, const int *,
      size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgeam2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const cuComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cuComplex *beta, const cusparseMatDescr_t descrB, int nnzB,
    const cuComplex *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    const cuComplex *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cusparseMatDescr_t,
      int, const cuComplex *, const int *, const int *, const cuComplex *,
      const cusparseMatDescr_t, int, const cuComplex *, const int *,
      const int *, const cusparseMatDescr_t, const cuComplex *, const int *,
      const int *, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgeam2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam2_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const cuDoubleComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cuDoubleComplex *beta,
    const cusparseMatDescr_t descrB, int nnzB,
    const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    const cuDoubleComplex *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
      const int *, const cuDoubleComplex *, const cusparseMatDescr_t, int,
      const cuDoubleComplex *, const int *, const int *,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgeam2_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsrgeam2Nnz(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    int nnzA, const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrB, int nnzB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *workspace) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, int, const int *,
      const int *, const cusparseMatDescr_t, int, const int *, const int *,
      const cusparseMatDescr_t, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrgeam2Nnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, nnzA, csrSortedRowPtrA,
                  csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB,
                  csrSortedColIndB, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, workspace);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrgeam2(
    cusparseHandle_t handle, int m, int n, const float *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, const float *beta,
    const cusparseMatDescr_t descrB, int nnzB, const float *csrSortedValB,
    const int *csrSortedRowPtrB, const int *csrSortedColIndB,
    const cusparseMatDescr_t descrC, float *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, const cusparseMatDescr_t, int,
      const float *, const int *, const int *, const float *,
      const cusparseMatDescr_t, int, const float *, const int *, const int *,
      const cusparseMatDescr_t, float *, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrgeam2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam2(
    cusparseHandle_t handle, int m, int n, const double *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const double *beta, const cusparseMatDescr_t descrB, int nnzB,
    const double *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    double *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, const cusparseMatDescr_t, int,
      const double *, const int *, const int *, const double *,
      const cusparseMatDescr_t, int, const double *, const int *, const int *,
      const cusparseMatDescr_t, double *, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrgeam2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam2(
    cusparseHandle_t handle, int m, int n, const cuComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cuComplex *beta, const cusparseMatDescr_t descrB, int nnzB,
    const cuComplex *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    cuComplex *csrSortedValC, int *csrSortedRowPtrC, int *csrSortedColIndC,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuComplex *, const cusparseMatDescr_t,
      int, const cuComplex *, const int *, const int *, const cuComplex *,
      const cusparseMatDescr_t, int, const cuComplex *, const int *,
      const int *, const cusparseMatDescr_t, cuComplex *, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrgeam2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam2(
    cusparseHandle_t handle, int m, int n, const cuDoubleComplex *alpha,
    const cusparseMatDescr_t descrA, int nnzA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cuDoubleComplex *beta,
    const cusparseMatDescr_t descrB, int nnzB,
    const cuDoubleComplex *csrSortedValB, const int *csrSortedRowPtrB,
    const int *csrSortedColIndB, const cusparseMatDescr_t descrC,
    cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
    int *csrSortedColIndC, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cuDoubleComplex *,
      const cusparseMatDescr_t, int, const cuDoubleComplex *, const int *,
      const int *, const cuDoubleComplex *, const cusparseMatDescr_t, int,
      const cuDoubleComplex *, const int *, const int *,
      const cusparseMatDescr_t, cuDoubleComplex *, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrgeam2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, alpha, descrA, nnzA, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA, beta, descrB, nnzB,
                  csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsrcolor(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const float *fractionToColor, int *ncolors,
    int *coloring, int *reordering, const cusparseColorInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, const float *, int *, int *, int *,
      const cusparseColorInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsrcolor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, fractionToColor, ncolors, coloring,
                  reordering, info);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsrcolor(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const double *fractionToColor, int *ncolors,
    int *coloring, int *reordering, const cusparseColorInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, const double *, int *, int *, int *,
      const cusparseColorInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsrcolor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, fractionToColor, ncolors, coloring,
                  reordering, info);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsrcolor(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const float *fractionToColor, int *ncolors,
    int *coloring, int *reordering, const cusparseColorInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, const float *, int *, int *, int *,
      const cusparseColorInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsrcolor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, fractionToColor, ncolors, coloring,
                  reordering, info);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsrcolor(
    cusparseHandle_t handle, int m, int nnz, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const double *fractionToColor, int *ncolors,
    int *coloring, int *reordering, const cusparseColorInfo_t info) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, const double *, int *,
      int *, int *, const cusparseColorInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsrcolor");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, nnz, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, fractionToColor, ncolors, coloring,
                  reordering, info);
}

cusparseStatus_t CUSPARSEAPI
cusparseSnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
             const cusparseMatDescr_t descrA, const float *A, int lda,
             int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, int, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSnnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
                  nnzTotalDevHostPtr);
}

cusparseStatus_t CUSPARSEAPI
cusparseDnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
             const cusparseMatDescr_t descrA, const double *A, int lda,
             int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, int, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
                  nnzTotalDevHostPtr);
}

cusparseStatus_t CUSPARSEAPI
cusparseCnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
             const cusparseMatDescr_t descrA, const cuComplex *A, int lda,
             int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, int, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCnnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
                  nnzTotalDevHostPtr);
}

cusparseStatus_t CUSPARSEAPI
cusparseZnnz(cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
             const cusparseMatDescr_t descrA, const cuDoubleComplex *A, int lda,
             int *nnzPerRowCol, int *nnzTotalDevHostPtr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, int, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZnnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, A, lda, nnzPerRowCol,
                  nnzTotalDevHostPtr);
}

cusparseStatus_t CUSPARSEAPI cusparseSnnz_compress(
    cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
    const float *csrSortedValA, const int *csrSortedRowPtrA, int *nnzPerRow,
    int *nnzC, float tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cusparseMatDescr_t, const float *,
      const int *, int *, int *, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSnnz_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
                  nnzC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseDnnz_compress(
    cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
    const double *csrSortedValA, const int *csrSortedRowPtrA, int *nnzPerRow,
    int *nnzC, double tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cusparseMatDescr_t, const double *,
      const int *, int *, int *, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnnz_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
                  nnzC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseCnnz_compress(
    cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA, int *nnzPerRow,
    int *nnzC, cuComplex tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, int *, int *, cuComplex);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCnnz_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
                  nnzC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseZnnz_compress(
    cusparseHandle_t handle, int m, const cusparseMatDescr_t descr,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    int *nnzPerRow, int *nnzC, cuDoubleComplex tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, const cusparseMatDescr_t, const cuDoubleComplex *,
      const int *, int *, int *, cuDoubleComplex);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZnnz_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, descr, csrSortedValA, csrSortedRowPtrA, nnzPerRow,
                  nnzC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseScsr2csr_compress(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const float *csrSortedValA, const int *csrSortedColIndA,
    const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
    float *csrSortedValC, int *csrSortedColIndC, int *csrSortedRowPtrC,
    float tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, int, const int *, float *, int *, int *, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csr_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
                  csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
                  csrSortedColIndC, csrSortedRowPtrC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsr2csr_compress(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const double *csrSortedValA, const int *csrSortedColIndA,
    const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
    double *csrSortedValC, int *csrSortedColIndC, int *csrSortedRowPtrC,
    double tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, int, const int *, double *, int *, int *,
      double);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csr_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
                  csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
                  csrSortedColIndC, csrSortedRowPtrC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsr2csr_compress(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedColIndA,
    const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
    cuComplex *csrSortedValC, int *csrSortedColIndC, int *csrSortedRowPtrC,
    cuComplex tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, int, const int *, cuComplex *, int *, int *,
      cuComplex);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csr_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
                  csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
                  csrSortedColIndC, csrSortedRowPtrC, tol);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsr2csr_compress(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedColIndA,
    const int *csrSortedRowPtrA, int nnzA, const int *nnzPerRow,
    cuDoubleComplex *csrSortedValC, int *csrSortedColIndC,
    int *csrSortedRowPtrC, cuDoubleComplex tol) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, const int *,
      cuDoubleComplex *, int *, int *, cuDoubleComplex);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csr_compress");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedColIndA,
                  csrSortedRowPtrA, nnzA, nnzPerRow, csrSortedValC,
                  csrSortedColIndC, csrSortedRowPtrC, tol);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseSdense2csr(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const float *A, int lda, const int *nnzPerRow, float *csrSortedValA,
    int *csrSortedRowPtrA, int *csrSortedColIndA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
      const int *, float *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseDdense2csr(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const double *A, int lda, const int *nnzPerRow, double *csrSortedValA,
    int *csrSortedRowPtrA, int *csrSortedColIndA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
      const int *, double *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseCdense2csr(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuComplex *A, int lda, const int *nnzPerRow, cuComplex *csrSortedValA,
    int *csrSortedRowPtrA, int *csrSortedColIndA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      int, const int *, cuComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseZdense2csr(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *A, int lda, const int *nnzPerRow,
    cuDoubleComplex *csrSortedValA, int *csrSortedRowPtrA,
    int *csrSortedColIndA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, int, const int *, cuDoubleComplex *, int *,
      int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerRow, csrSortedValA,
                  csrSortedRowPtrA, csrSortedColIndA);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseScsr2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const float *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, float *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, float *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseDcsr2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const double *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, double *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, double *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseCcsr2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, cuComplex *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, cuComplex *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseZcsr2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *csrSortedValA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, cuDoubleComplex *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *,
      int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseSdense2csc(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const float *A, int lda, const int *nnzPerCol, float *cscSortedValA,
    int *cscSortedRowIndA, int *cscSortedColPtrA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *, int,
      const int *, float *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSdense2csc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
                  cscSortedRowIndA, cscSortedColPtrA);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseDdense2csc(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const double *A, int lda, const int *nnzPerCol, double *cscSortedValA,
    int *cscSortedRowIndA, int *cscSortedColPtrA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *, int,
      const int *, double *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDdense2csc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
                  cscSortedRowIndA, cscSortedColPtrA);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseCdense2csc(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuComplex *A, int lda, const int *nnzPerCol, cuComplex *cscSortedValA,
    int *cscSortedRowIndA, int *cscSortedColPtrA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      int, const int *, cuComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCdense2csc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
                  cscSortedRowIndA, cscSortedColPtrA);
}

CUSPARSE_DEPRECATED(cusparseDenseToSparse)
cusparseStatus_t CUSPARSEAPI cusparseZdense2csc(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *A, int lda, const int *nnzPerCol,
    cuDoubleComplex *cscSortedValA, int *cscSortedRowIndA,
    int *cscSortedColPtrA) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, int, const int *, cuDoubleComplex *, int *,
      int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZdense2csc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, A, lda, nnzPerCol, cscSortedValA,
                  cscSortedRowIndA, cscSortedColPtrA);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseScsc2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const float *cscSortedValA, const int *cscSortedRowIndA,
    const int *cscSortedColPtrA, float *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, float *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsc2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
                  cscSortedColPtrA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseDcsc2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const double *cscSortedValA, const int *cscSortedRowIndA,
    const int *cscSortedColPtrA, double *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, double *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsc2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
                  cscSortedColPtrA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseCcsc2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuComplex *cscSortedValA, const int *cscSortedRowIndA,
    const int *cscSortedColPtrA, cuComplex *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t, const cuComplex *,
      const int *, const int *, cuComplex *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsc2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
                  cscSortedColPtrA, A, lda);
}

CUSPARSE_DEPRECATED(cusparseSparseToDense)
cusparseStatus_t CUSPARSEAPI cusparseZcsc2dense(
    cusparseHandle_t handle, int m, int n, const cusparseMatDescr_t descrA,
    const cuDoubleComplex *cscSortedValA, const int *cscSortedRowIndA,
    const int *cscSortedColPtrA, cuDoubleComplex *A, int lda) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, cuDoubleComplex *,
      int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsc2dense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, descrA, cscSortedValA, cscSortedRowIndA,
                  cscSortedColPtrA, A, lda);
}

cusparseStatus_t CUSPARSEAPI cusparseXcoo2csr(cusparseHandle_t handle,
                                              const int *cooRowInd, int nnz,
                                              int m, int *csrSortedRowPtr,
                                              cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, const int *, int, int, int *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoo2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, cooRowInd, nnz, m, csrSortedRowPtr, idxBase);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsr2coo(cusparseHandle_t handle,
                                              const int *csrSortedRowPtr,
                                              int nnz, int m, int *cooRowInd,
                                              cusparseIndexBase_t idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, const int *, int, int, int *, cusparseIndexBase_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2coo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, csrSortedRowPtr, nnz, m, cooRowInd, idxBase);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsr2bsrNnz(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, int blockDim, const cusparseMatDescr_t descrC,
    int *bsrSortedRowPtrC, int *nnzTotalDevHostPtr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const int *, const int *, int, const cusparseMatDescr_t, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2bsrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedRowPtrA,
                  csrSortedColIndA, blockDim, descrC, bsrSortedRowPtrC,
                  nnzTotalDevHostPtr);
}

cusparseStatus_t CUSPARSEAPI cusparseScsr2bsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, float *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, const cusparseMatDescr_t,
      float *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2bsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, blockDim, descrC, bsrSortedValC,
                  bsrSortedRowPtrC, bsrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsr2bsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, double *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, const cusparseMatDescr_t,
      double *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2bsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, blockDim, descrC, bsrSortedValC,
                  bsrSortedRowPtrC, bsrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsr2bsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int,
      const cusparseMatDescr_t, cuComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2bsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, blockDim, descrC, bsrSortedValC,
                  bsrSortedRowPtrC, bsrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsr2bsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, cuDoubleComplex *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int,
      const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2bsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, blockDim, descrC, bsrSortedValC,
                  bsrSortedRowPtrC, bsrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseSbsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, float *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, const cusparseMatDescr_t,
      float *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSbsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, blockDim, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseDbsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, double *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, const cusparseMatDescr_t,
      double *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDbsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, blockDim, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseCbsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int,
      const cusparseMatDescr_t, cuComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCbsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, blockDim, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseZbsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int blockDim,
    const cusparseMatDescr_t descrC, cuDoubleComplex *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int,
      const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZbsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, blockDim, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSize(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const float *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const float *, const int *, const int *,
      int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSize(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const double *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const double *, const int *, const int *,
      int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSize(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuComplex *, const int *,
      const int *, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSize(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
      const int *, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSizeExt(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const float *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const float *, const int *, const int *,
      int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSizeExt(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const double *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const double *, const int *, const int *,
      int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSizeExt(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuComplex *, const int *,
      const int *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSizeExt(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
      const int *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const float *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim, float *bscVal,
    int *bscRowInd, int *bscColPtr, cusparseAction_t copyValues,
    cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const float *, const int *, const int *,
      int, int, float *, int *, int *, cusparseAction_t, cusparseIndexBase_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
                  bscColPtr, copyValues, idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const double *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    double *bscVal, int *bscRowInd, int *bscColPtr, cusparseAction_t copyValues,
    cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const double *, const int *, const int *,
      int, int, double *, int *, int *, cusparseAction_t, cusparseIndexBase_t,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
                  bscColPtr, copyValues, idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const cuComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    cuComplex *bscVal, int *bscRowInd, int *bscColPtr,
    cusparseAction_t copyValues, cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuComplex *, const int *,
      const int *, int, int, cuComplex *, int *, int *, cusparseAction_t,
      cusparseIndexBase_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
                  bscColPtr, copyValues, idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc(
    cusparseHandle_t handle, int mb, int nb, int nnzb,
    const cuDoubleComplex *bsrSortedVal, const int *bsrSortedRowPtr,
    const int *bsrSortedColInd, int rowBlockDim, int colBlockDim,
    cuDoubleComplex *bscVal, int *bscRowInd, int *bscColPtr,
    cusparseAction_t copyValues, cusparseIndexBase_t idxBase, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cuDoubleComplex *, const int *,
      const int *, int, int, cuDoubleComplex *, int *, int *, cusparseAction_t,
      cusparseIndexBase_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, mb, nb, nnzb, bsrSortedVal, bsrSortedRowPtr,
                  bsrSortedColInd, rowBlockDim, colBlockDim, bscVal, bscRowInd,
                  bscColPtr, copyValues, idxBase, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXgebsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const int *bsrSortedRowPtrA,
    const int *bsrSortedColIndA, int rowBlockDim, int colBlockDim,
    const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
    int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const int *, const int *, int, int, const cusparseMatDescr_t, int *,
      int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXgebsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedRowPtrA,
                  bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
                  csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
    int colBlockDim, const cusparseMatDescr_t descrC, float *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, int,
      const cusparseMatDescr_t, float *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
    int colBlockDim, const cusparseMatDescr_t descrC, double *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, int,
      const cusparseMatDescr_t, double *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
    int colBlockDim, const cusparseMatDescr_t descrC, cuComplex *csrSortedValC,
    int *csrSortedRowPtrC, int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int, int,
      const cusparseMatDescr_t, cuComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2csr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDim,
    int colBlockDim, const cusparseMatDescr_t descrC,
    cuDoubleComplex *csrSortedValC, int *csrSortedRowPtrC,
    int *csrSortedColIndC) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, int,
      const cusparseMatDescr_t, cuDoubleComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, descrA, bsrSortedValA, bsrSortedRowPtrA,
                  bsrSortedColIndA, rowBlockDim, colBlockDim, descrC,
                  csrSortedValC, csrSortedRowPtrC, csrSortedColIndC);
}

cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseScsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDcsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCcsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, int rowBlockDim,
    int colBlockDim, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZcsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, rowBlockDim, colBlockDim, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsr2gebsrNnz(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const int *csrSortedRowPtrA,
    const int *csrSortedColIndA, const cusparseMatDescr_t descrC,
    int *bsrSortedRowPtrC, int rowBlockDim, int colBlockDim,
    int *nnzTotalDevHostPtr, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const int *, const int *, const cusparseMatDescr_t, int *, int, int,
      int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsr2gebsrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedRowPtrA,
                  csrSortedColIndA, descrC, bsrSortedRowPtrC, rowBlockDim,
                  colBlockDim, nnzTotalDevHostPtr, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrC, float *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
    int colBlockDim, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const float *, const int *, const int *, const cusparseMatDescr_t,
      float *, int *, int *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrC, double *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
    int colBlockDim, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const double *, const int *, const int *, const cusparseMatDescr_t,
      double *, int *, int *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
    int colBlockDim, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuComplex *, const int *, const int *, const cusparseMatDescr_t,
      cuComplex *, int *, int *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int m, int n,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const cusparseMatDescr_t descrC, cuDoubleComplex *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDim,
    int colBlockDim, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, const cusparseMatDescr_t,
      const cuDoubleComplex *, const int *, const int *,
      const cusparseMatDescr_t, cuDoubleComplex *, int *, int *, int, int,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, m, n, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDim, colBlockDim, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const float *, const int *, const int *, int,
      int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const double *, const int *, const int *, int,
      int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      int, int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSize(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC,
    int *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, int, int, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const float *, const int *, const int *, int,
      int, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const double *, const int *, const int *, int,
      int, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      int, int, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSizeExt(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, int rowBlockDimC, int colBlockDimC, size_t *pBufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, int, int, int, int, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, rowBlockDimC, colBlockDimC, pBufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseXgebsr2gebsrNnz(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const int *bsrSortedRowPtrA,
    const int *bsrSortedColIndA, int rowBlockDimA, int colBlockDimA,
    const cusparseMatDescr_t descrC, int *bsrSortedRowPtrC, int rowBlockDimC,
    int colBlockDimC, int *nnzTotalDevHostPtr, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const int *, const int *, int, int,
      const cusparseMatDescr_t, int *, int, int, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXgebsr2gebsrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedRowPtrA,
                  bsrSortedColIndA, rowBlockDimA, colBlockDimA, descrC,
                  bsrSortedRowPtrC, rowBlockDimC, colBlockDimC,
                  nnzTotalDevHostPtr, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const float *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, const cusparseMatDescr_t descrC, float *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
    int colBlockDimC, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const float *, const int *, const int *, int,
      int, const cusparseMatDescr_t, float *, int *, int *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSgebsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const double *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, const cusparseMatDescr_t descrC, double *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
    int colBlockDimC, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const double *, const int *, const int *, int,
      int, const cusparseMatDescr_t, double *, int *, int *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDgebsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const cuComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, const cusparseMatDescr_t descrC, cuComplex *bsrSortedValC,
    int *bsrSortedRowPtrC, int *bsrSortedColIndC, int rowBlockDimC,
    int colBlockDimC, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const cuComplex *, const int *, const int *,
      int, int, const cusparseMatDescr_t, cuComplex *, int *, int *, int, int,
      void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCgebsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr(
    cusparseHandle_t handle, cusparseDirection_t dirA, int mb, int nb, int nnzb,
    const cusparseMatDescr_t descrA, const cuDoubleComplex *bsrSortedValA,
    const int *bsrSortedRowPtrA, const int *bsrSortedColIndA, int rowBlockDimA,
    int colBlockDimA, const cusparseMatDescr_t descrC,
    cuDoubleComplex *bsrSortedValC, int *bsrSortedRowPtrC,
    int *bsrSortedColIndC, int rowBlockDimC, int colBlockDimC, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDirection_t, int, int, int,
      const cusparseMatDescr_t, const cuDoubleComplex *, const int *,
      const int *, int, int, const cusparseMatDescr_t, cuDoubleComplex *, int *,
      int *, int, int, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZgebsr2gebsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, dirA, mb, nb, nnzb, descrA, bsrSortedValA,
                  bsrSortedRowPtrA, bsrSortedColIndA, rowBlockDimA,
                  colBlockDimA, descrC, bsrSortedValC, bsrSortedRowPtrC,
                  bsrSortedColIndC, rowBlockDimC, colBlockDimC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseCreateIdentityPermutation(cusparseHandle_t handle, int n, int *p) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseHandle_t, int, int *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseCreateIdentityPermutation");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, p);
}

cusparseStatus_t CUSPARSEAPI cusparseXcoosort_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, const int *cooRowsA,
    const int *cooColsA, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosort_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseXcoosortByRow(cusparseHandle_t handle,
                                                   int m, int n, int nnz,
                                                   int *cooRowsA, int *cooColsA,
                                                   int *P, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, int *, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosortByRow");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, P, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXcoosortByColumn(cusparseHandle_t handle,
                                                      int m, int n, int nnz,
                                                      int *cooRowsA,
                                                      int *cooColsA, int *P,
                                                      void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, int *, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcoosortByColumn");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, cooRowsA, cooColsA, P, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsrsort_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, const int *csrRowPtrA,
    const int *csrColIndA, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsort_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrRowPtrA, csrColIndA,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseXcsrsort(cusparseHandle_t handle, int m,
                                              int n, int nnz,
                                              const cusparseMatDescr_t descrA,
                                              const int *csrRowPtrA,
                                              int *csrColIndA, int *P,
                                              void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const int *,
      int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcsrsort");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrRowPtrA, csrColIndA, P,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseXcscsort_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, const int *cscColPtrA,
    const int *cscRowIndA, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const int *, const int *, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcscsort_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, cscColPtrA, cscRowIndA,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseXcscsort(cusparseHandle_t handle, int m,
                                              int n, int nnz,
                                              const cusparseMatDescr_t descrA,
                                              const int *cscColPtrA,
                                              int *cscRowIndA, int *P,
                                              void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const int *,
      int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseXcscsort");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, cscColPtrA, cscRowIndA, P,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsru2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, float *csrVal,
    const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, float *, const int *, int *,
      csru2csrInfo_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsru2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, double *csrVal,
    const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, double *, const int *, int *,
      csru2csrInfo_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsru2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, cuComplex *csrVal,
    const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, cuComplex *, const int *, int *,
      csru2csrInfo_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsru2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnz, cuDoubleComplex *csrVal,
    const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, cuDoubleComplex *, const int *, int *,
      csru2csrInfo_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsru2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, info,
                  pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseScsru2csr(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, float *csrVal, const int *csrRowPtr,
    int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, float *,
      const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsru2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, double *csrVal, const int *csrRowPtr,
    int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, double *,
      const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsru2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, cuComplex *csrVal, const int *csrRowPtr,
    int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsru2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, cuDoubleComplex *csrVal,
    const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsru2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseScsr2csru(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, float *csrVal, const int *csrRowPtr,
    int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, float *,
      const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScsr2csru");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDcsr2csru(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, double *csrVal, const int *csrRowPtr,
    int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, double *,
      const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDcsr2csru");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCcsr2csru(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, cuComplex *csrVal, const int *csrRowPtr,
    int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, cuComplex *,
      const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCcsr2csru");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseZcsr2csru(
    cusparseHandle_t handle, int m, int n, int nnz,
    const cusparseMatDescr_t descrA, cuDoubleComplex *csrVal,
    const int *csrRowPtr, int *csrColInd, csru2csrInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t,
      cuDoubleComplex *, const int *, int *, csru2csrInfo_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseZcsr2csru");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, descrA, csrVal, csrRowPtr, csrColInd, info,
                  pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const float *A, int lda,
    const float *threshold, const cusparseMatDescr_t descrC,
    const float *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, int, const float *,
      const cusparseMatDescr_t, const float *, const int *, const int *,
      size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneDense2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const double *A, int lda,
    const double *threshold, const cusparseMatDescr_t descrC,
    const double *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, int, const double *,
      const cusparseMatDescr_t, const double *, const int *, const int *,
      size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneDense2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnz(
    cusparseHandle_t handle, int m, int n, const float *A, int lda,
    const float *threshold, const cusparseMatDescr_t descrC, int *csrRowPtrC,
    int *nnzTotalDevHostPtr, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, int, const float *,
      const cusparseMatDescr_t, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneDense2csrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, threshold, descrC, csrRowPtrC,
                  nnzTotalDevHostPtr, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnz(
    cusparseHandle_t handle, int m, int n, const double *A, int lda,
    const double *threshold, const cusparseMatDescr_t descrC,
    int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, int, const double *,
      const cusparseMatDescr_t, int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneDense2csrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr(
    cusparseHandle_t handle, int m, int n, const float *A, int lda,
    const float *threshold, const cusparseMatDescr_t descrC,
    float *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, int, const float *,
      const cusparseMatDescr_t, float *, const int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneDense2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr(
    cusparseHandle_t handle, int m, int n, const double *A, int lda,
    const double *threshold, const cusparseMatDescr_t descrC,
    double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, int, const double *,
      const cusparseMatDescr_t, double *, const int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneDense2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const float *threshold, const cusparseMatDescr_t descrC,
    const float *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, const float *, const cusparseMatDescr_t,
      const float *, const int *, const int *, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneCsr2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const double *threshold, const cusparseMatDescr_t descrC,
    const double *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, const double *, const cusparseMatDescr_t,
      const double *, const int *, const int *, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneCsr2csr_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnz(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const float *threshold, const cusparseMatDescr_t descrC,
    int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, const float *, const cusparseMatDescr_t, int *,
      int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, threshold, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnz(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const double *threshold, const cusparseMatDescr_t descrC,
    int *csrSortedRowPtrC, int *nnzTotalDevHostPtr, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, const double *, const cusparseMatDescr_t, int *,
      int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrNnz");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, threshold, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const float *threshold, const cusparseMatDescr_t descrC,
    float *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, const float *, const cusparseMatDescr_t,
      float *, const int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpruneCsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA,
    const double *threshold, const cusparseMatDescr_t descrC,
    double *csrSortedValC, const int *csrSortedRowPtrC, int *csrSortedColIndC,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, const double *, const cusparseMatDescr_t,
      double *, const int *, int *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDpruneCsr2csr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, threshold, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const float *A, int lda,
    float percentage, const cusparseMatDescr_t descrC,
    const float *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, pruneInfo_t info, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, int, float,
      const cusparseMatDescr_t, const float *, const int *, const int *,
      pruneInfo_t, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneDense2csrByPercentage_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, const double *A, int lda,
    float percentage, const cusparseMatDescr_t descrC,
    const double *csrSortedValC, const int *csrSortedRowPtrC,
    const int *csrSortedColIndC, pruneInfo_t info, size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, int, float,
      const cusparseMatDescr_t, const double *, const int *, const int *,
      pruneInfo_t, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneDense2csrByPercentage_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnzByPercentage(
    cusparseHandle_t handle, int m, int n, const float *A, int lda,
    float percentage, const cusparseMatDescr_t descrC, int *csrRowPtrC,
    int *nnzTotalDevHostPtr, pruneInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, int, float,
      const cusparseMatDescr_t, int *, int *, pruneInfo_t, void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneDense2csrNnzByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, percentage, descrC, csrRowPtrC,
                  nnzTotalDevHostPtr, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnzByPercentage(
    cusparseHandle_t handle, int m, int n, const double *A, int lda,
    float percentage, const cusparseMatDescr_t descrC, int *csrRowPtrC,
    int *nnzTotalDevHostPtr, pruneInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, int, float,
      const cusparseMatDescr_t, int *, int *, pruneInfo_t, void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneDense2csrNnzByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, percentage, descrC, csrRowPtrC,
                  nnzTotalDevHostPtr, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage(
    cusparseHandle_t handle, int m, int n, const float *A, int lda,
    float percentage, const cusparseMatDescr_t descrC, float *csrSortedValC,
    const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const float *, int, float,
      const cusparseMatDescr_t, float *, const int *, int *, pruneInfo_t,
      void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneDense2csrByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage(
    cusparseHandle_t handle, int m, int n, const double *A, int lda,
    float percentage, const cusparseMatDescr_t descrC, double *csrSortedValC,
    const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, const double *, int, float,
      const cusparseMatDescr_t, double *, const int *, int *, pruneInfo_t,
      void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneDense2csrByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float percentage,
    const cusparseMatDescr_t descrC, const float *csrSortedValC,
    const int *csrSortedRowPtrC, const int *csrSortedColIndC, pruneInfo_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, float, const cusparseMatDescr_t, const float *,
      const int *, const int *, pruneInfo_t, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrByPercentage_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage_bufferSizeExt(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float percentage,
    const cusparseMatDescr_t descrC, const double *csrSortedValC,
    const int *csrSortedRowPtrC, const int *csrSortedColIndC, pruneInfo_t info,
    size_t *pBufferSizeInBytes) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, float, const cusparseMatDescr_t, const double *,
      const int *, const int *, pruneInfo_t, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrByPercentage_bufferSizeExt");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBufferSizeInBytes);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnzByPercentage(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float percentage,
    const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
    int *nnzTotalDevHostPtr, pruneInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, float, const cusparseMatDescr_t, int *, int *,
      pruneInfo_t, void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrNnzByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, percentage, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnzByPercentage(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float percentage,
    const cusparseMatDescr_t descrC, int *csrSortedRowPtrC,
    int *nnzTotalDevHostPtr, pruneInfo_t info, void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, float, const cusparseMatDescr_t, int *, int *,
      pruneInfo_t, void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrNnzByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, percentage, descrC, csrSortedRowPtrC,
                  nnzTotalDevHostPtr, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const float *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float percentage,
    const cusparseMatDescr_t descrC, float *csrSortedValC,
    const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const float *,
      const int *, const int *, float, const cusparseMatDescr_t, float *,
      const int *, int *, pruneInfo_t, void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSpruneCsr2csrByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage(
    cusparseHandle_t handle, int m, int n, int nnzA,
    const cusparseMatDescr_t descrA, const double *csrSortedValA,
    const int *csrSortedRowPtrA, const int *csrSortedColIndA, float percentage,
    const cusparseMatDescr_t descrC, double *csrSortedValC,
    const int *csrSortedRowPtrC, int *csrSortedColIndC, pruneInfo_t info,
    void *pBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const cusparseMatDescr_t, const double *,
      const int *, const int *, float, const cusparseMatDescr_t, double *,
      const int *, int *, pruneInfo_t, void *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDpruneCsr2csrByPercentage");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnzA, descrA, csrSortedValA, csrSortedRowPtrA,
                  csrSortedColIndA, percentage, descrC, csrSortedValC,
                  csrSortedRowPtrC, csrSortedColIndC, info, pBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCsr2cscEx2(
    cusparseHandle_t handle, int m, int n, int nnz, const void *csrVal,
    const int *csrRowPtr, const int *csrColInd, void *cscVal, int *cscColPtr,
    int *cscRowInd, cudaDataType valType, cusparseAction_t copyValues,
    cusparseIndexBase_t idxBase, cusparseCsr2CscAlg_t alg, void *buffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const void *, const int *, const int *,
      void *, int *, int *, cudaDataType, cusparseAction_t, cusparseIndexBase_t,
      cusparseCsr2CscAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsr2cscEx2");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal,
                  cscColPtr, cscRowInd, valType, copyValues, idxBase, alg,
                  buffer);
}

cusparseStatus_t CUSPARSEAPI cusparseCsr2cscEx2_bufferSize(
    cusparseHandle_t handle, int m, int n, int nnz, const void *csrVal,
    const int *csrRowPtr, const int *csrColInd, void *cscVal, int *cscColPtr,
    int *cscRowInd, cudaDataType valType, cusparseAction_t copyValues,
    cusparseIndexBase_t idxBase, cusparseCsr2CscAlg_t alg, size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, int, int, int, const void *, const int *, const int *,
      void *, int *, int *, cudaDataType, cusparseAction_t, cusparseIndexBase_t,
      cusparseCsr2CscAlg_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsr2cscEx2_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, nnz, csrVal, csrRowPtr, csrColInd, cscVal,
                  cscColPtr, cscRowInd, valType, copyValues, idxBase, alg,
                  bufferSize);
}

cusparseStatus_t CUSPARSEAPI
cusparseCreateSpVec(cusparseSpVecDescr_t *spVecDescr, int64_t size, int64_t nnz,
                    void *indices, void *values, cusparseIndexType_t idxType,
                    cusparseIndexBase_t idxBase, cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpVecDescr_t *, int64_t, int64_t, void *, void *,
      cusparseIndexType_t, cusparseIndexBase_t, cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateSpVec");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spVecDescr, size, nnz, indices, values, idxType, idxBase,
                  valueType);
}

cusparseStatus_t CUSPARSEAPI
cusparseDestroySpVec(cusparseSpVecDescr_t spVecDescr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpVecDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroySpVec");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spVecDescr);
}

cusparseStatus_t CUSPARSEAPI cusparseSpVecGet(cusparseSpVecDescr_t spVecDescr,
                                              int64_t *size, int64_t *nnz,
                                              void **indices, void **values,
                                              cusparseIndexType_t *idxType,
                                              cusparseIndexBase_t *idxBase,
                                              cudaDataType *valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpVecDescr_t, int64_t *, int64_t *, void **, void **,
      cusparseIndexType_t *, cusparseIndexBase_t *, cudaDataType *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpVecGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spVecDescr, size, nnz, indices, values, idxType, idxBase,
                  valueType);
}

cusparseStatus_t CUSPARSEAPI cusparseSpVecGetIndexBase(
    cusparseSpVecDescr_t spVecDescr, cusparseIndexBase_t *idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpVecDescr_t,
                                                  cusparseIndexBase_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpVecGetIndexBase");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spVecDescr, idxBase);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpVecGetValues(cusparseSpVecDescr_t spVecDescr, void **values) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseSpVecDescr_t, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpVecGetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spVecDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpVecSetValues(cusparseSpVecDescr_t spVecDescr, void *values) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpVecDescr_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpVecSetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spVecDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseCreateDnVec(cusparseDnVecDescr_t *dnVecDescr, int64_t size,
                    void *values, cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseDnVecDescr_t *, int64_t, void *, cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateDnVec");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnVecDescr, size, values, valueType);
}

cusparseStatus_t CUSPARSEAPI
cusparseDestroyDnVec(cusparseDnVecDescr_t dnVecDescr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseDnVecDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyDnVec");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnVecDescr);
}

cusparseStatus_t CUSPARSEAPI cusparseDnVecGet(cusparseDnVecDescr_t dnVecDescr,
                                              int64_t *size, void **values,
                                              cudaDataType *valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseDnVecDescr_t, int64_t *, void **, cudaDataType *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnVecGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnVecDescr, size, values, valueType);
}

cusparseStatus_t CUSPARSEAPI
cusparseDnVecGetValues(cusparseDnVecDescr_t dnVecDescr, void **values) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseDnVecDescr_t, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnVecGetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnVecDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseDnVecSetValues(cusparseDnVecDescr_t dnVecDescr, void *values) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseDnVecDescr_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnVecSetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnVecDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseDestroySpMat(cusparseSpMatDescr_t spMatDescr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroySpMat");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr);
}

cusparseStatus_t CUSPARSEAPI cusparseSpMatGetFormat(
    cusparseSpMatDescr_t spMatDescr, cusparseFormat_t *format) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, cusparseFormat_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatGetFormat");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, format);
}

cusparseStatus_t CUSPARSEAPI cusparseSpMatGetIndexBase(
    cusparseSpMatDescr_t spMatDescr, cusparseIndexBase_t *idxBase) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t,
                                                  cusparseIndexBase_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatGetIndexBase");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, idxBase);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpMatGetValues(cusparseSpMatDescr_t spMatDescr, void **values) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatGetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpMatSetValues(cusparseSpMatDescr_t spMatDescr, void *values) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatSetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpMatGetSize(cusparseSpMatDescr_t spMatDescr, int64_t *rows,
                     int64_t *cols, int64_t *nnz) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, int64_t *, int64_t *, int64_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatGetSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpMatSetStridedBatch(cusparseSpMatDescr_t spMatDescr, int batchCount) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatSetStridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, batchCount);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpMatGetStridedBatch(cusparseSpMatDescr_t spMatDescr, int *batchCount) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatGetStridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, batchCount);
}

cusparseStatus_t CUSPARSEAPI cusparseCooSetStridedBatch(
    cusparseSpMatDescr_t spMatDescr, int batchCount, int64_t batchStride) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, int, int64_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCooSetStridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, batchCount, batchStride);
}

cusparseStatus_t CUSPARSEAPI cusparseCsrSetStridedBatch(
    cusparseSpMatDescr_t spMatDescr, int batchCount, int64_t offsetsBatchStride,
    int64_t columnsValuesBatchStride) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, int,
                                                  int64_t, int64_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrSetStridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, batchCount, offsetsBatchStride,
                  columnsValuesBatchStride);
}

#if CUDA_VERSION >= 11030

cusparseStatus_t CUSPARSEAPI cusparseSpMatGetAttribute(
    cusparseSpMatDescr_t spMatDescr, cusparseSpMatAttribute_t attribute,
    void *data, size_t dataSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, cusparseSpMatAttribute_t, void *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatGetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, attribute, data, dataSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSpMatSetAttribute(
    cusparseSpMatDescr_t spMatDescr, cusparseSpMatAttribute_t attribute,
    void *data, size_t dataSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, cusparseSpMatAttribute_t, void *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMatSetAttribute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, attribute, data, dataSize);
}

#endif  // CUDA_VERSION >= 11030

cusparseStatus_t CUSPARSEAPI cusparseCreateCsr(
    cusparseSpMatDescr_t *spMatDescr, int64_t rows, int64_t cols, int64_t nnz,
    void *csrRowOffsets, void *csrColInd, void *csrValues,
    cusparseIndexType_t csrRowOffsetsType, cusparseIndexType_t csrColIndType,
    cusparseIndexBase_t idxBase, cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t *, int64_t, int64_t, int64_t, void *, void *, void *,
      cusparseIndexType_t, cusparseIndexType_t, cusparseIndexBase_t,
      cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, csrRowOffsets, csrColInd,
                  csrValues, csrRowOffsetsType, csrColIndType, idxBase,
                  valueType);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateCsc(
    cusparseSpMatDescr_t *spMatDescr, int64_t rows, int64_t cols, int64_t nnz,
    void *cscColOffsets, void *cscRowInd, void *cscValues,
    cusparseIndexType_t cscColOffsetsType, cusparseIndexType_t cscRowIndType,
    cusparseIndexBase_t idxBase, cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t *, int64_t, int64_t, int64_t, void *, void *, void *,
      cusparseIndexType_t, cusparseIndexType_t, cusparseIndexBase_t,
      cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCsc");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, cscColOffsets, cscRowInd,
                  cscValues, cscColOffsetsType, cscRowIndType, idxBase,
                  valueType);
}

cusparseStatus_t CUSPARSEAPI cusparseCsrGet(
    cusparseSpMatDescr_t spMatDescr, int64_t *rows, int64_t *cols, int64_t *nnz,
    void **csrRowOffsets, void **csrColInd, void **csrValues,
    cusparseIndexType_t *csrRowOffsetsType, cusparseIndexType_t *csrColIndType,
    cusparseIndexBase_t *idxBase, cudaDataType *valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, int64_t *, int64_t *, int64_t *, void **, void **,
      void **, cusparseIndexType_t *, cusparseIndexType_t *,
      cusparseIndexBase_t *, cudaDataType *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, csrRowOffsets, csrColInd,
                  csrValues, csrRowOffsetsType, csrColIndType, idxBase,
                  valueType);
}

cusparseStatus_t CUSPARSEAPI
cusparseCsrSetPointers(cusparseSpMatDescr_t spMatDescr, void *csrRowOffsets,
                       void *csrColInd, void *csrValues) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, void *,
                                                  void *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCsrSetPointers");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, csrRowOffsets, csrColInd, csrValues);
}

cusparseStatus_t CUSPARSEAPI
cusparseCscSetPointers(cusparseSpMatDescr_t spMatDescr, void *cscColOffsets,
                       void *cscRowInd, void *cscValues) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, void *,
                                                  void *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCscSetPointers");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, cscColOffsets, cscRowInd, cscValues);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateCoo(cusparseSpMatDescr_t *spMatDescr,
                                               int64_t rows, int64_t cols,
                                               int64_t nnz, void *cooRowInd,
                                               void *cooColInd, void *cooValues,
                                               cusparseIndexType_t cooIdxType,
                                               cusparseIndexBase_t idxBase,
                                               cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t *, int64_t, int64_t, int64_t, void *, void *, void *,
      cusparseIndexType_t, cusparseIndexBase_t, cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCoo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, cooRowInd, cooColInd, cooValues,
                  cooIdxType, idxBase, valueType);
}

CUSPARSE_DEPRECATED(cusparseCreateCoo)
cusparseStatus_t CUSPARSEAPI cusparseCreateCooAoS(
    cusparseSpMatDescr_t *spMatDescr, int64_t rows, int64_t cols, int64_t nnz,
    void *cooInd, void *cooValues, cusparseIndexType_t cooIdxType,
    cusparseIndexBase_t idxBase, cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t *, int64_t, int64_t, int64_t, void *, void *,
      cusparseIndexType_t, cusparseIndexBase_t, cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateCooAoS");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, cooInd, cooValues, cooIdxType,
                  idxBase, valueType);
}

cusparseStatus_t CUSPARSEAPI cusparseCooGet(
    cusparseSpMatDescr_t spMatDescr, int64_t *rows, int64_t *cols, int64_t *nnz,
    void **cooRowInd,  // COO row indices
    void **cooColInd,  // COO column indices
    void **cooValues,  // COO values
    cusparseIndexType_t *idxType, cusparseIndexBase_t *idxBase,
    cudaDataType *valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, int64_t *, int64_t *, int64_t *, void **, void **,
      void **, cusparseIndexType_t *, cusparseIndexBase_t *, cudaDataType *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCooGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, cooRowInd, cooColInd, cooValues,
                  idxType, idxBase, valueType);
}

CUSPARSE_DEPRECATED(cusparseCooGet)
cusparseStatus_t CUSPARSEAPI cusparseCooAoSGet(cusparseSpMatDescr_t spMatDescr,
                                               int64_t *rows, int64_t *cols,
                                               int64_t *nnz,
                                               void **cooInd,     // COO indices
                                               void **cooValues,  // COO values
                                               cusparseIndexType_t *idxType,
                                               cusparseIndexBase_t *idxBase,
                                               cudaDataType *valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, int64_t *, int64_t *, int64_t *, void **, void **,
      cusparseIndexType_t *, cusparseIndexBase_t *, cudaDataType *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCooAoSGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, nnz, cooInd, cooValues, idxType,
                  idxBase, valueType);
}

cusparseStatus_t CUSPARSEAPI
cusparseCooSetPointers(cusparseSpMatDescr_t spMatDescr, void *cooRows,
                       void *cooColumns, void *cooValues) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpMatDescr_t, void *,
                                                  void *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCooSetPointers");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, cooRows, cooColumns, cooValues);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateBlockedEll(
    cusparseSpMatDescr_t *spMatDescr, int64_t rows, int64_t cols,
    int64_t ellBlockSize, int64_t ellCols, void *ellColInd, void *ellValue,
    cusparseIndexType_t ellIdxType, cusparseIndexBase_t idxBase,
    cudaDataType valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t *, int64_t, int64_t, int64_t, int64_t, void *,
      void *, cusparseIndexType_t, cusparseIndexBase_t, cudaDataType);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateBlockedEll");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, ellBlockSize, ellCols, ellColInd,
                  ellValue, ellIdxType, idxBase, valueType);
}

cusparseStatus_t CUSPARSEAPI cusparseBlockedEllGet(
    cusparseSpMatDescr_t spMatDescr, int64_t *rows, int64_t *cols,
    int64_t *ellBlockSize, int64_t *ellCols, void **ellColInd, void **ellValue,
    cusparseIndexType_t *ellIdxType, cusparseIndexBase_t *idxBase,
    cudaDataType *valueType) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseSpMatDescr_t, int64_t *, int64_t *, int64_t *, int64_t *, void **,
      void **, cusparseIndexType_t *, cusparseIndexBase_t *, cudaDataType *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseBlockedEllGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(spMatDescr, rows, cols, ellBlockSize, ellCols, ellColInd,
                  ellValue, ellIdxType, idxBase, valueType);
}

cusparseStatus_t CUSPARSEAPI cusparseCreateDnMat(
    cusparseDnMatDescr_t *dnMatDescr, int64_t rows, int64_t cols, int64_t ld,
    void *values, cudaDataType valueType, cusparseOrder_t order) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseDnMatDescr_t *, int64_t, int64_t, int64_t, void *, cudaDataType,
      cusparseOrder_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseCreateDnMat");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr, rows, cols, ld, values, valueType, order);
}

cusparseStatus_t CUSPARSEAPI
cusparseDestroyDnMat(cusparseDnMatDescr_t dnMatDescr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseDnMatDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDestroyDnMat");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr);
}

cusparseStatus_t CUSPARSEAPI cusparseDnMatGet(cusparseDnMatDescr_t dnMatDescr,
                                              int64_t *rows, int64_t *cols,
                                              int64_t *ld, void **values,
                                              cudaDataType *type,
                                              cusparseOrder_t *order) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseDnMatDescr_t, int64_t *, int64_t *, int64_t *, void **,
      cudaDataType *, cusparseOrder_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnMatGet");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr, rows, cols, ld, values, type, order);
}

cusparseStatus_t CUSPARSEAPI
cusparseDnMatGetValues(cusparseDnMatDescr_t dnMatDescr, void **values) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseDnMatDescr_t, void **);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnMatGetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr, values);
}

cusparseStatus_t CUSPARSEAPI
cusparseDnMatSetValues(cusparseDnMatDescr_t dnMatDescr, void *values) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseDnMatDescr_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnMatSetValues");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr, values);
}

cusparseStatus_t CUSPARSEAPI cusparseDnMatSetStridedBatch(
    cusparseDnMatDescr_t dnMatDescr, int batchCount, int64_t batchStride) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseDnMatDescr_t, int, int64_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnMatSetStridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr, batchCount, batchStride);
}

cusparseStatus_t CUSPARSEAPI cusparseDnMatGetStridedBatch(
    cusparseDnMatDescr_t dnMatDescr, int *batchCount, int64_t *batchStride) {
  using FuncPtr =
      cusparseStatus_t(CUSPARSEAPI *)(cusparseDnMatDescr_t, int *, int64_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDnMatGetStridedBatch");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(dnMatDescr, batchCount, batchStride);
}

cusparseStatus_t CUSPARSEAPI cusparseAxpby(cusparseHandle_t handle,
                                           const void *alpha,
                                           cusparseSpVecDescr_t vecX,
                                           const void *beta,
                                           cusparseDnVecDescr_t vecY) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, const void *, cusparseSpVecDescr_t, const void *,
      cusparseDnVecDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseAxpby");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, alpha, vecX, beta, vecY);
}

cusparseStatus_t CUSPARSEAPI cusparseGather(cusparseHandle_t handle,
                                            cusparseDnVecDescr_t vecY,
                                            cusparseSpVecDescr_t vecX) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDnVecDescr_t, cusparseSpVecDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseGather");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, vecY, vecX);
}

cusparseStatus_t CUSPARSEAPI cusparseScatter(cusparseHandle_t handle,
                                             cusparseSpVecDescr_t vecX,
                                             cusparseDnVecDescr_t vecY) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseSpVecDescr_t, cusparseDnVecDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseScatter");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, vecX, vecY);
}

cusparseStatus_t CUSPARSEAPI cusparseRot(cusparseHandle_t handle,
                                         const void *c_coeff,
                                         const void *s_coeff,
                                         cusparseSpVecDescr_t vecX,
                                         cusparseDnVecDescr_t vecY) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, const void *, const void *, cusparseSpVecDescr_t,
      cusparseDnVecDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseRot");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, c_coeff, s_coeff, vecX, vecY);
}

cusparseStatus_t CUSPARSEAPI cusparseSpVV_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t opX, cusparseSpVecDescr_t vecX,
    cusparseDnVecDescr_t vecY, const void *result, cudaDataType computeType,
    size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseSpVecDescr_t,
      cusparseDnVecDescr_t, const void *, cudaDataType, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpVV_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opX, vecX, vecY, result, computeType, bufferSize);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpVV(cusparseHandle_t handle, cusparseOperation_t opX,
             cusparseSpVecDescr_t vecX, cusparseDnVecDescr_t vecY, void *result,
             cudaDataType computeType, void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseSpVecDescr_t,
      cusparseDnVecDescr_t, void *, cudaDataType, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpVV");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opX, vecX, vecY, result, computeType, externalBuffer);
}

#if CUSPARSE_VERSION >= 11300

cusparseStatus_t CUSPARSEAPI cusparseSparseToDense_bufferSize(
    cusparseHandle_t handle, cusparseSpMatDescr_t matA,
    cusparseDnMatDescr_t matB, cusparseSparseToDenseAlg_t alg,
    size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseSpMatDescr_t, cusparseDnMatDescr_t,
      cusparseSparseToDenseAlg_t, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseSparseToDense_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, matA, matB, alg, bufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSparseToDense(
    cusparseHandle_t handle, cusparseSpMatDescr_t matA,
    cusparseDnMatDescr_t matB, cusparseSparseToDenseAlg_t alg, void *buffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseSpMatDescr_t, cusparseDnMatDescr_t,
      cusparseSparseToDenseAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSparseToDense");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, matA, matB, alg, buffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDenseToSparse_bufferSize(
    cusparseHandle_t handle, cusparseDnMatDescr_t matA,
    cusparseSpMatDescr_t matB, cusparseDenseToSparseAlg_t alg,
    size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDnMatDescr_t, cusparseSpMatDescr_t,
      cusparseDenseToSparseAlg_t, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseDenseToSparse_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, matA, matB, alg, bufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseDenseToSparse_analysis(
    cusparseHandle_t handle, cusparseDnMatDescr_t matA,
    cusparseSpMatDescr_t matB, cusparseDenseToSparseAlg_t alg, void *buffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDnMatDescr_t, cusparseSpMatDescr_t,
      cusparseDenseToSparseAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDenseToSparse_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, matA, matB, alg, buffer);
}

cusparseStatus_t CUSPARSEAPI cusparseDenseToSparse_convert(
    cusparseHandle_t handle, cusparseDnMatDescr_t matA,
    cusparseSpMatDescr_t matB, cusparseDenseToSparseAlg_t alg, void *buffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseDnMatDescr_t, cusparseSpMatDescr_t,
      cusparseDenseToSparseAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseDenseToSparse_convert");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, matA, matB, alg, buffer);
}

#endif  // CUSPARSE_VERSION >= 11300

cusparseStatus_t CUSPARSEAPI cusparseSpMV(
    cusparseHandle_t handle, cusparseOperation_t opA, const void *alpha,
    cusparseSpMatDescr_t matA, cusparseDnVecDescr_t vecX, const void *beta,
    cusparseDnVecDescr_t vecY, cudaDataType computeType, cusparseSpMVAlg_t alg,
    void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, const void *, cusparseSpMatDescr_t,
      cusparseDnVecDescr_t, const void *, cusparseDnVecDescr_t, cudaDataType,
      cusparseSpMVAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMV");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg,
                  externalBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpMV_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t opA, const void *alpha,
    cusparseSpMatDescr_t matA, cusparseDnVecDescr_t vecX, const void *beta,
    cusparseDnVecDescr_t vecY, cudaDataType computeType, cusparseSpMVAlg_t alg,
    size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, const void *, cusparseSpMatDescr_t,
      cusparseDnVecDescr_t, const void *, cusparseDnVecDescr_t, cudaDataType,
      cusparseSpMVAlg_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMV_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg,
                  bufferSize);
}

#if CUDA_VERSION >= 11030

cusparseStatus_t CUSPARSEAPI
cusparseSpSV_createDescr(cusparseSpSVDescr_t *descr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpSVDescr_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpSV_createDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descr);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpSV_destroyDescr(cusparseSpSVDescr_t descr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpSVDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpSV_destroyDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descr);
}

cusparseStatus_t CUSPARSEAPI cusparseSpSV_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t opA, const void *alpha,
    cusparseSpMatDescr_t matA, cusparseDnVecDescr_t vecX,
    cusparseDnVecDescr_t vecY, cudaDataType computeType, cusparseSpSVAlg_t alg,
    cusparseSpSVDescr_t spsvDescr, size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, const void *, cusparseSpMatDescr_t,
      cusparseDnVecDescr_t, cusparseDnVecDescr_t, cudaDataType,
      cusparseSpSVAlg_t, cusparseSpSVDescr_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpSV_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, alpha, matA, vecX, vecY, computeType, alg,
                  spsvDescr, bufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSpSV_analysis(
    cusparseHandle_t handle, cusparseOperation_t opA, const void *alpha,
    cusparseSpMatDescr_t matA, cusparseDnVecDescr_t vecX,
    cusparseDnVecDescr_t vecY, cudaDataType computeType, cusparseSpSVAlg_t alg,
    cusparseSpSVDescr_t spsvDescr, void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, const void *, cusparseSpMatDescr_t,
      cusparseDnVecDescr_t, cusparseDnVecDescr_t, cudaDataType,
      cusparseSpSVAlg_t, cusparseSpSVDescr_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpSV_analysis");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, alpha, matA, vecX, vecY, computeType, alg,
                  spsvDescr, externalBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpSV_solve(
    cusparseHandle_t handle, cusparseOperation_t opA, const void *alpha,
    cusparseSpMatDescr_t matA, cusparseDnVecDescr_t vecX,
    cusparseDnVecDescr_t vecY, cudaDataType computeType, cusparseSpSVAlg_t alg,
    cusparseSpSVDescr_t spsvDescr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, const void *, cusparseSpMatDescr_t,
      cusparseDnVecDescr_t, cusparseDnVecDescr_t, cudaDataType,
      cusparseSpSVAlg_t, cusparseSpSVDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpSV_solve");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, alpha, matA, vecX, vecY, computeType, alg,
                  spsvDescr);
}

#endif  // CUDA_VERSION >= 11030

cusparseStatus_t CUSPARSEAPI cusparseSpMM_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseSpMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseDnMatDescr_t matC, cudaDataType computeType,
    cusparseSpMMAlg_t alg, size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseSpMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseDnMatDescr_t, cudaDataType, cusparseSpMMAlg_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMM_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, bufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSpMM_preprocess(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseSpMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseDnMatDescr_t matC, cudaDataType computeType,
    cusparseSpMMAlg_t alg, void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseSpMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseDnMatDescr_t, cudaDataType, cusparseSpMMAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMM_preprocess");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, externalBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSpMM(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseSpMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseDnMatDescr_t matC, cudaDataType computeType,
    cusparseSpMMAlg_t alg, void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseSpMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseDnMatDescr_t, cudaDataType, cusparseSpMMAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpMM");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, externalBuffer);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpGEMM_createDescr(cusparseSpGEMMDescr_t *descr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpGEMMDescr_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpGEMM_createDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descr);
}

cusparseStatus_t CUSPARSEAPI
cusparseSpGEMM_destroyDescr(cusparseSpGEMMDescr_t descr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(cusparseSpGEMMDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpGEMM_destroyDescr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(descr);
}

cusparseStatus_t CUSPARSEAPI cusparseSpGEMM_workEstimation(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseSpMatDescr_t matA, cusparseSpMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    cusparseSpGEMMAlg_t alg, cusparseSpGEMMDescr_t spgemmDescr,
    size_t *bufferSize1, void *externalBuffer1) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseSpMatDescr_t, cusparseSpMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, cusparseSpGEMMAlg_t,
      cusparseSpGEMMDescr_t, size_t *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpGEMM_workEstimation");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, spgemmDescr, bufferSize1, externalBuffer1);
}

cusparseStatus_t CUSPARSEAPI cusparseSpGEMM_compute(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseSpMatDescr_t matA, cusparseSpMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    cusparseSpGEMMAlg_t alg, cusparseSpGEMMDescr_t spgemmDescr,
    size_t *bufferSize2, void *externalBuffer2) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseSpMatDescr_t, cusparseSpMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, cusparseSpGEMMAlg_t,
      cusparseSpGEMMDescr_t, size_t *, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpGEMM_compute");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, spgemmDescr, bufferSize2, externalBuffer2);
}

cusparseStatus_t CUSPARSEAPI cusparseSpGEMM_copy(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseSpMatDescr_t matA, cusparseSpMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    cusparseSpGEMMAlg_t alg, cusparseSpGEMMDescr_t spgemmDescr) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseSpMatDescr_t, cusparseSpMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, cusparseSpGEMMAlg_t,
      cusparseSpGEMMDescr_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSpGEMM_copy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, spgemmDescr);
}

CUSPARSE_DEPRECATED(cusparseSDDMM)
cusparseStatus_t CUSPARSEAPI cusparseConstrainedGeMM(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseDnMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseDnMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseConstrainedGeMM");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  externalBuffer);
}

CUSPARSE_DEPRECATED(cusparseSDDMM)
cusparseStatus_t CUSPARSEAPI cusparseConstrainedGeMM_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseDnMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseDnMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, size_t *);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusparseConstrainedGeMM_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  bufferSize);
}

#if CUSPARSE_VERSION >= 11400

cusparseStatus_t CUSPARSEAPI cusparseSDDMM_bufferSize(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseDnMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    cusparseSDDMMAlg_t alg, size_t *bufferSize) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseDnMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, cusparseSDDMMAlg_t, size_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSDDMM_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, bufferSize);
}

cusparseStatus_t CUSPARSEAPI cusparseSDDMM_preprocess(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseDnMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    cusparseSDDMMAlg_t alg, void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseDnMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, cusparseSDDMMAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSDDMM_preprocess");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, externalBuffer);
}

cusparseStatus_t CUSPARSEAPI cusparseSDDMM(
    cusparseHandle_t handle, cusparseOperation_t opA, cusparseOperation_t opB,
    const void *alpha, cusparseDnMatDescr_t matA, cusparseDnMatDescr_t matB,
    const void *beta, cusparseSpMatDescr_t matC, cudaDataType computeType,
    cusparseSDDMMAlg_t alg, void *externalBuffer) {
  using FuncPtr = cusparseStatus_t(CUSPARSEAPI *)(
      cusparseHandle_t, cusparseOperation_t, cusparseOperation_t, const void *,
      cusparseDnMatDescr_t, cusparseDnMatDescr_t, const void *,
      cusparseSpMatDescr_t, cudaDataType, cusparseSDDMMAlg_t, void *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusparseSDDMM");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, opA, opB, alpha, matA, matB, beta, matC, computeType,
                  alg, externalBuffer);
}

#endif  // CUSPARSE_VERSION >= 11400

}  // extern "C"