// Auto-generated, do not edit.

extern "C" {

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

cusolverStatus_t CUSOLVERAPI cusolverDnCreate(cusolverDnHandle_t *handle) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCreate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDestroy(cusolverDnHandle_t handle) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDestroy");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSetStream(cusolverDnHandle_t handle,
                                                 cudaStream_t streamId) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cudaStream_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSetStream");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, streamId);
}

cusolverStatus_t CUSOLVERAPI cusolverDnGetStream(cusolverDnHandle_t handle,
                                                 cudaStream_t *streamId) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cudaStream_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnGetStream");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, streamId);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnSpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
                            int n, float *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnDpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
                            int n, double *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnCpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
                            int n, cuComplex *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZpotrf_bufferSize(cusolverDnHandle_t handle, cublasFillMode_t uplo,
                            int n, cuDoubleComplex *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSpotrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              float *A, int lda,
                                              float *Workspace, int Lwork,
                                              int *devInfo) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
                                      float *, int, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDpotrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              double *A, int lda,
                                              double *Workspace, int Lwork,
                                              int *devInfo) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
                                      double *, int, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCpotrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              cuComplex *A, int lda,
                                              cuComplex *Workspace, int Lwork,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, cuComplex *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZpotrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              cuDoubleComplex *A, int lda,
                                              cuDoubleComplex *Workspace,
                                              int Lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int,
      cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSpotrs(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              int nrhs, const float *A, int lda,
                                              float *B, int ldb, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, const float *, int,
      float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDpotrs(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              int nrhs, const double *A,
                                              int lda, double *B, int ldb,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, const double *, int,
      double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCpotrs(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              int nrhs, const cuComplex *A,
                                              int lda, cuComplex *B, int ldb,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, const cuComplex *, int,
      cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZpotrs(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              int nrhs,
                                              const cuDoubleComplex *A, int lda,
                                              cuDoubleComplex *B, int ldb,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, const cuDoubleComplex *,
      int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSpotrfBatched(cusolverDnHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n, float *Aarray[],
                                                     int lda, int *infoArray,
                                                     int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, float *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrfBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDpotrfBatched(cusolverDnHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n, double *Aarray[],
                                                     int lda, int *infoArray,
                                                     int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, double *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrfBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCpotrfBatched(cusolverDnHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n, cuComplex *Aarray[],
                                                     int lda, int *infoArray,
                                                     int batchSize) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
                                      cuComplex *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrfBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZpotrfBatched(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
    cuDoubleComplex *Aarray[], int lda, int *infoArray, int batchSize) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
                                      cuDoubleComplex *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrfBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, Aarray, lda, infoArray, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSpotrsBatched(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
    int nrhs, /* only support rhs = 1*/
    float *A[], int lda, float *B[], int ldb, int *d_info, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, float *[], int, float *[],
      int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSpotrsBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDpotrsBatched(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
    int nrhs, /* only support rhs = 1*/
    double *A[], int lda, double *B[], int ldb, int *d_info, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, double *[], int,
      double *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDpotrsBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnCpotrsBatched(cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
                        int nrhs, /* only support rhs = 1*/
                        cuComplex *A[], int lda, cuComplex *B[], int ldb,
                        int *d_info, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, cuComplex *[], int,
      cuComplex *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCpotrsBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZpotrsBatched(cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
                        int nrhs, /* only support rhs = 1*/
                        cuDoubleComplex *A[], int lda, cuDoubleComplex *B[],
                        int ldb, int *d_info, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, int, cuDoubleComplex *[], int,
      cuDoubleComplex *[], int, int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZpotrsBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, nrhs, A, lda, B, ldb, d_info, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgetrf_bufferSize(
    cusolverDnHandle_t handle, int m, int n, float *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgetrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgetrf_bufferSize(
    cusolverDnHandle_t handle, int m, int n, double *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgetrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnCgetrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
                            cuComplex *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgetrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZgetrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
                            cuDoubleComplex *A, int lda, int *Lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgetrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgetrf(cusolverDnHandle_t handle, int m,
                                              int n, float *A, int lda,
                                              float *Workspace, int *devIpiv,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, float *, int, float *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgetrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgetrf(cusolverDnHandle_t handle, int m,
                                              int n, double *A, int lda,
                                              double *Workspace, int *devIpiv,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, double *, int, double *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgetrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgetrf(cusolverDnHandle_t handle, int m,
                                              int n, cuComplex *A, int lda,
                                              cuComplex *Workspace,
                                              int *devIpiv, int *devInfo) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, cuComplex *,
                                      int, cuComplex *, int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgetrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgetrf(cusolverDnHandle_t handle, int m,
                                              int n, cuDoubleComplex *A,
                                              int lda,
                                              cuDoubleComplex *Workspace,
                                              int *devIpiv, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, cuDoubleComplex *, int, cuDoubleComplex *,
      int *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgetrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, Workspace, devIpiv, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSlaswp(cusolverDnHandle_t handle, int n,
                                              float *A, int lda, int k1, int k2,
                                              const int *devIpiv, int incx) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, float *, int, int, int, const int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSlaswp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDlaswp(cusolverDnHandle_t handle, int n,
                                              double *A, int lda, int k1,
                                              int k2, const int *devIpiv,
                                              int incx) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, double *, int, int, int, const int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDlaswp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
}

cusolverStatus_t CUSOLVERAPI cusolverDnClaswp(cusolverDnHandle_t handle, int n,
                                              cuComplex *A, int lda, int k1,
                                              int k2, const int *devIpiv,
                                              int incx) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, cuComplex *, int, int, int, const int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnClaswp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZlaswp(cusolverDnHandle_t handle, int n,
                                              cuDoubleComplex *A, int lda,
                                              int k1, int k2,
                                              const int *devIpiv, int incx) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
                                                  cuDoubleComplex *, int, int,
                                                  int, const int *, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZlaswp");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, k1, k2, devIpiv, incx);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgetrs(cusolverDnHandle_t handle,
                                              cublasOperation_t trans, int n,
                                              int nrhs, const float *A, int lda,
                                              const int *devIpiv, float *B,
                                              int ldb, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasOperation_t, int, int, const float *, int,
      const int *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgetrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgetrs(cusolverDnHandle_t handle,
                                              cublasOperation_t trans, int n,
                                              int nrhs, const double *A,
                                              int lda, const int *devIpiv,
                                              double *B, int ldb,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasOperation_t, int, int, const double *, int,
      const int *, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgetrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgetrs(cusolverDnHandle_t handle,
                                              cublasOperation_t trans, int n,
                                              int nrhs, const cuComplex *A,
                                              int lda, const int *devIpiv,
                                              cuComplex *B, int ldb,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasOperation_t, int, int, const cuComplex *, int,
      const int *, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgetrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgetrs(
    cusolverDnHandle_t handle, cublasOperation_t trans, int n, int nrhs,
    const cuDoubleComplex *A, int lda, const int *devIpiv, cuDoubleComplex *B,
    int ldb, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasOperation_t, int, int, const cuDoubleComplex *,
      int, const int *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgetrs");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgeqrf_bufferSize(
    cusolverDnHandle_t handle, int m, int n, float *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgeqrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgeqrf_bufferSize(
    cusolverDnHandle_t handle, int m, int n, double *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgeqrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnCgeqrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
                            cuComplex *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgeqrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZgeqrf_bufferSize(cusolverDnHandle_t handle, int m, int n,
                            cuDoubleComplex *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgeqrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgeqrf(cusolverDnHandle_t handle, int m,
                                              int n, float *A, int lda,
                                              float *TAU, float *Workspace,
                                              int Lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, float *, int, float *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgeqrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgeqrf(cusolverDnHandle_t handle, int m,
                                              int n, double *A, int lda,
                                              double *TAU, double *Workspace,
                                              int Lwork, int *devInfo) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, double *,
                                      int, double *, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgeqrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgeqrf(cusolverDnHandle_t handle, int m,
                                              int n, cuComplex *A, int lda,
                                              cuComplex *TAU,
                                              cuComplex *Workspace, int Lwork,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  cuComplex *, int, cuComplex *,
                                                  cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgeqrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgeqrf(cusolverDnHandle_t handle, int m,
                                              int n, cuDoubleComplex *A,
                                              int lda, cuDoubleComplex *TAU,
                                              cuDoubleComplex *Workspace,
                                              int Lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, cuDoubleComplex *, int, cuDoubleComplex *,
      cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgeqrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, TAU, Workspace, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSorgqr_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int k, const float *A, int lda,
    const float *tau, int *lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int,
                                      const float *, int, const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDorgqr_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int k, const double *A, int lda,
    const double *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  int, const double *, int,
                                                  const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCungqr_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int k, const cuComplex *A, int lda,
    const cuComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int,
                                                  int, const cuComplex *, int,
                                                  const cuComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZungqr_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int k, const cuDoubleComplex *A,
    int lda, const cuDoubleComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, int, const cuDoubleComplex *, int,
      const cuDoubleComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSorgqr(cusolverDnHandle_t handle, int m,
                                              int n, int k, float *A, int lda,
                                              const float *tau, float *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, int, float *, int, const float *, float *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDorgqr(cusolverDnHandle_t handle, int m,
                                              int n, int k, double *A, int lda,
                                              const double *tau, double *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, int, double *, int, const double *,
      double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCungqr(cusolverDnHandle_t handle, int m,
                                              int n, int k, cuComplex *A,
                                              int lda, const cuComplex *tau,
                                              cuComplex *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, int, cuComplex *, int, const cuComplex *,
      cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZungqr(
    cusolverDnHandle_t handle, int m, int n, int k, cuDoubleComplex *A, int lda,
    const cuDoubleComplex *tau, cuDoubleComplex *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, int, cuDoubleComplex *, int,
      const cuDoubleComplex *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSormqr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const float *A, int lda, const float *tau,
    const float *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const float *, int, const float *, const float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDormqr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const double *A, int lda, const double *tau,
    const double *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const double *, int, const double *, const double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCunmqr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const cuComplex *A, int lda, const cuComplex *tau,
    const cuComplex *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const cuComplex *, int, const cuComplex *, const cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZunmqr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const cuDoubleComplex *A, int lda,
    const cuDoubleComplex *tau, const cuDoubleComplex *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const cuDoubleComplex *, int, const cuDoubleComplex *,
      const cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmqr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSormqr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const float *A, int lda, const float *tau, float *C,
    int ldc, float *work, int lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const float *, int, const float *, float *, int, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
                  lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDormqr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const double *A, int lda, const double *tau, double *C,
    int ldc, double *work, int lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const double *, int, const double *, double *, int, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
                  lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCunmqr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const cuComplex *A, int lda, const cuComplex *tau,
    cuComplex *C, int ldc, cuComplex *work, int lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const cuComplex *, int, const cuComplex *, cuComplex *, int, cuComplex *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
                  lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZunmqr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasOperation_t trans,
    int m, int n, int k, const cuDoubleComplex *A, int lda,
    const cuDoubleComplex *tau, cuDoubleComplex *C, int ldc,
    cuDoubleComplex *work, int lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasOperation_t, int, int, int,
      const cuDoubleComplex *, int, const cuDoubleComplex *, cuDoubleComplex *,
      int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmqr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, trans, m, n, k, A, lda, tau, C, ldc, work,
                  lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsytrf_bufferSize(
    cusolverDnHandle_t handle, int n, float *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
                                                  float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsytrf_bufferSize(
    cusolverDnHandle_t handle, int n, double *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
                                                  double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCsytrf_bufferSize(
    cusolverDnHandle_t handle, int n, cuComplex *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int,
                                                  cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCsytrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZsytrf_bufferSize(
    cusolverDnHandle_t handle, int n, cuDoubleComplex *A, int lda, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZsytrf_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, n, A, lda, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsytrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              float *A, int lda, int *ipiv,
                                              float *work, int lwork,
                                              int *info) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
                                      float *, int, int *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsytrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              double *A, int lda, int *ipiv,
                                              double *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, double *, int, int *, double *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCsytrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              cuComplex *A, int lda, int *ipiv,
                                              cuComplex *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, int *,
      cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCsytrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZsytrf(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              cuDoubleComplex *A, int lda,
                                              int *ipiv, cuDoubleComplex *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int, int *,
      cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZsytrf");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, ipiv, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgebrd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *Lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgebrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgebrd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *Lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgebrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgebrd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *Lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgebrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgebrd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *Lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgebrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, Lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgebrd(cusolverDnHandle_t handle, int m,
                                              int n, float *A, int lda,
                                              float *D, float *E, float *TAUQ,
                                              float *TAUP, float *Work,
                                              int Lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, float *, int, float *, float *, float *,
      float *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgebrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgebrd(cusolverDnHandle_t handle, int m,
                                              int n, double *A, int lda,
                                              double *D, double *E,
                                              double *TAUQ, double *TAUP,
                                              double *Work, int Lwork,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, double *, int, double *, double *, double *,
      double *, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgebrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgebrd(cusolverDnHandle_t handle, int m,
                                              int n, cuComplex *A, int lda,
                                              float *D, float *E,
                                              cuComplex *TAUQ, cuComplex *TAUP,
                                              cuComplex *Work, int Lwork,
                                              int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, cuComplex *, int, float *, float *,
      cuComplex *, cuComplex *, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgebrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgebrd(
    cusolverDnHandle_t handle, int m, int n, cuDoubleComplex *A, int lda,
    double *D, double *E, cuDoubleComplex *TAUQ, cuDoubleComplex *TAUP,
    cuDoubleComplex *Work, int Lwork, int *devInfo) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, int, int, cuDoubleComplex *, int, double *, double *,
      cuDoubleComplex *, cuDoubleComplex *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgebrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, A, lda, D, E, TAUQ, TAUP, Work, Lwork, devInfo);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSorgbr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
    const float *A, int lda, const float *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, const float *, int,
      const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgbr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDorgbr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
    const double *A, int lda, const double *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, const double *, int,
      const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgbr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCungbr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
    const cuComplex *A, int lda, const cuComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, const cuComplex *,
      int, const cuComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungbr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZungbr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n, int k,
    const cuDoubleComplex *A, int lda, const cuDoubleComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int,
      const cuDoubleComplex *, int, const cuDoubleComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungbr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSorgbr(cusolverDnHandle_t handle,
                                              cublasSideMode_t side, int m,
                                              int n, int k, float *A, int lda,
                                              const float *tau, float *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, float *, int,
      const float *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgbr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDorgbr(cusolverDnHandle_t handle,
                                              cublasSideMode_t side, int m,
                                              int n, int k, double *A, int lda,
                                              const double *tau, double *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, double *, int,
      const double *, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgbr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCungbr(cusolverDnHandle_t handle,
                                              cublasSideMode_t side, int m,
                                              int n, int k, cuComplex *A,
                                              int lda, const cuComplex *tau,
                                              cuComplex *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, cuComplex *, int,
      const cuComplex *, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungbr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZungbr(cusolverDnHandle_t handle, cublasSideMode_t side, int m, int n,
                 int k, cuDoubleComplex *A, int lda, const cuDoubleComplex *tau,
                 cuDoubleComplex *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, int, int, int, cuDoubleComplex *,
      int, const cuDoubleComplex *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungbr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, m, n, k, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsytrd_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const float *A,
    int lda, const float *d, const float *e, const float *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const float *, int,
      const float *, const float *, const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsytrd_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const double *A,
    int lda, const double *d, const double *e, const double *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const double *, int,
      const double *, const double *, const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnChetrd_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const cuComplex *A,
    int lda, const float *d, const float *e, const cuComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const cuComplex *, int,
      const float *, const float *, const cuComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChetrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZhetrd_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
    const cuDoubleComplex *A, int lda, const double *d, const double *e,
    const cuDoubleComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, int,
      const double *, const double *, const cuDoubleComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhetrd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsytrd(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              float *A, int lda, float *d,
                                              float *e, float *tau, float *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, float *, int, float *, float *,
      float *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsytrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsytrd(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, double *A, int lda,
    double *d, double *e, double *tau, double *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, double *, int, double *,
      double *, double *, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsytrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnChetrd(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              cuComplex *A, int lda, float *d,
                                              float *e, cuComplex *tau,
                                              cuComplex *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int, float *,
      float *, cuComplex *, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChetrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZhetrd(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, cuDoubleComplex *A,
    int lda, double *d, double *e, cuDoubleComplex *tau, cuDoubleComplex *work,
    int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int,
      double *, double *, cuDoubleComplex *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhetrd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, d, e, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSorgtr_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const float *A,
    int lda, const float *tau, int *lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, cublasFillMode_t, int,
                                      const float *, int, const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDorgtr_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const double *A,
    int lda, const double *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const double *, int,
      const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCungtr_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, const cuComplex *A,
    int lda, const cuComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const cuComplex *, int,
      const cuComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZungtr_bufferSize(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n,
    const cuDoubleComplex *A, int lda, const cuDoubleComplex *tau, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, const cuDoubleComplex *, int,
      const cuDoubleComplex *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSorgtr(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              float *A, int lda,
                                              const float *tau, float *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, float *, int, const float *,
      float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSorgtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDorgtr(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              double *A, int lda,
                                              const double *tau, double *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, double *, int, const double *,
      double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDorgtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCungtr(
    cusolverDnHandle_t handle, cublasFillMode_t uplo, int n, cuComplex *A,
    int lda, const cuComplex *tau, cuComplex *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuComplex *, int,
      const cuComplex *, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCungtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZungtr(cusolverDnHandle_t handle,
                                              cublasFillMode_t uplo, int n,
                                              cuDoubleComplex *A, int lda,
                                              const cuDoubleComplex *tau,
                                              cuDoubleComplex *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasFillMode_t, int, cuDoubleComplex *, int,
      const cuDoubleComplex *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZungtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, uplo, n, A, lda, tau, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSormtr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, const float *A, int lda,
    const float *tau, const float *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, const float *, int, const float *, const float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDormtr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, const double *A, int lda,
    const double *tau, const double *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, const double *, int, const double *, const double *, int,
      int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCunmtr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, const cuComplex *A, int lda,
    const cuComplex *tau, const cuComplex *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, const cuComplex *, int, const cuComplex *, const cuComplex *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZunmtr_bufferSize(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, const cuDoubleComplex *A, int lda,
    const cuDoubleComplex *tau, const cuDoubleComplex *C, int ldc, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, const cuDoubleComplex *, int, const cuDoubleComplex *,
      const cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmtr_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSormtr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, float *A, int lda, float *tau,
    float *C, int ldc, float *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, float *, int, float *, float *, int, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSormtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
                  lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDormtr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, double *A, int lda, double *tau,
    double *C, int ldc, double *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, double *, int, double *, double *, int, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDormtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
                  lwork, info);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnCunmtr(cusolverDnHandle_t handle, cublasSideMode_t side,
                 cublasFillMode_t uplo, cublasOperation_t trans, int m, int n,
                 cuComplex *A, int lda, cuComplex *tau, cuComplex *C, int ldc,
                 cuComplex *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, cuComplex *, int, cuComplex *, cuComplex *, int, cuComplex *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCunmtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
                  lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZunmtr(
    cusolverDnHandle_t handle, cublasSideMode_t side, cublasFillMode_t uplo,
    cublasOperation_t trans, int m, int n, cuDoubleComplex *A, int lda,
    cuDoubleComplex *tau, cuDoubleComplex *C, int ldc, cuDoubleComplex *work,
    int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cublasSideMode_t, cublasFillMode_t, cublasOperation_t,
      int, int, cuDoubleComplex *, int, cuDoubleComplex *, cuDoubleComplex *,
      int, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZunmtr");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work,
                  lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgesvd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgesvd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgesvd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgesvd_bufferSize(
    cusolverDnHandle_t handle, int m, int n, int *lwork) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, int, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, m, n, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgesvd(
    cusolverDnHandle_t handle, signed char jobu, signed char jobvt, int m,
    int n, float *A, int lda, float *S, float *U, int ldu, float *VT, int ldvt,
    float *work, int lwork, float *rwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, signed char, signed char, int, int, float *, int,
      float *, float *, int, float *, int, float *, int, float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
                  lwork, rwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgesvd(
    cusolverDnHandle_t handle, signed char jobu, signed char jobvt, int m,
    int n, double *A, int lda, double *S, double *U, int ldu, double *VT,
    int ldvt, double *work, int lwork, double *rwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, signed char, signed char, int, int, double *, int,
      double *, double *, int, double *, int, double *, int, double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
                  lwork, rwork, info);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnCgesvd(cusolverDnHandle_t handle, signed char jobu, signed char jobvt,
                 int m, int n, cuComplex *A, int lda, float *S, cuComplex *U,
                 int ldu, cuComplex *VT, int ldvt, cuComplex *work, int lwork,
                 float *rwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, signed char, signed char, int, int, cuComplex *, int,
      float *, cuComplex *, int, cuComplex *, int, cuComplex *, int, float *,
      int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
                  lwork, rwork, info);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZgesvd(cusolverDnHandle_t handle, signed char jobu, signed char jobvt,
                 int m, int n, cuDoubleComplex *A, int lda, double *S,
                 cuDoubleComplex *U, int ldu, cuDoubleComplex *VT, int ldvt,
                 cuDoubleComplex *work, int lwork, double *rwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, signed char, signed char, int, int, cuDoubleComplex *,
      int, double *, cuDoubleComplex *, int, cuDoubleComplex *, int,
      cuDoubleComplex *, int, double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, work,
                  lwork, rwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsyevd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const float *A, int lda, const float *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const float *, int, const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsyevd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const double *A, int lda, const double *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const double *, int, const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCheevd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const cuComplex *A, int lda, const float *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const cuComplex *, int, const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZheevd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const cuDoubleComplex *A, int lda, const double *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const cuDoubleComplex *, int, const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsyevd(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, float *A, int lda, float *W, float *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, float *,
      int, float *, float *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsyevd(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, double *A, int lda, double *W, double *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, double *,
      int, double *, double *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCheevd(cusolverDnHandle_t handle,
                                              cusolverEigMode_t jobz,
                                              cublasFillMode_t uplo, int n,
                                              cuComplex *A, int lda, float *W,
                                              cuComplex *work, int lwork,
                                              int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, cuComplex *,
      int, float *, cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZheevd(cusolverDnHandle_t handle,
                                              cusolverEigMode_t jobz,
                                              cublasFillMode_t uplo, int n,
                                              cuDoubleComplex *A, int lda,
                                              double *W, cuDoubleComplex *work,
                                              int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      cuDoubleComplex *, int, double *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsygvd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const float *A, int lda, const float *B,
    int ldb, const float *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const float *, int, const float *, int,
      const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsygvd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const double *A, int lda, const double *B,
    int ldb, const double *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const double *, int, const double *, int,
      const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnChegvd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const cuComplex *A, int lda,
    const cuComplex *B, int ldb, const float *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const cuComplex *, int, const cuComplex *, int,
      const float *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZhegvd_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const cuDoubleComplex *A, int lda,
    const cuDoubleComplex *B, int ldb, const double *W, int *lwork) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const cuDoubleComplex *, int,
      const cuDoubleComplex *, int, const double *, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvd_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsygvd(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, float *A, int lda, float *B, int ldb,
    float *W, float *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, float *, int, float *, int, float *, float *, int,
      int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsygvd(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, double *A, int lda, double *B, int ldb,
    double *W, double *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, double *, int, double *, int, double *, double *,
      int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnChegvd(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, cuComplex *A, int lda, cuComplex *B, int ldb,
    float *W, cuComplex *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, cuComplex *, int, cuComplex *, int, float *,
      cuComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info);
}

cusolverStatus_t CUSOLVERAPI
cusolverDnZhegvd(cusolverDnHandle_t handle, cusolverEigType_t itype,
                 cusolverEigMode_t jobz, cublasFillMode_t uplo, int n,
                 cuDoubleComplex *A, int lda, cuDoubleComplex *B, int ldb,
                 double *W, cuDoubleComplex *work, int lwork, int *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int,
      double *, cuDoubleComplex *, int, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvd");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCreateSyevjInfo(syevjInfo_t *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCreateSyevjInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDestroySyevjInfo(syevjInfo_t info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDestroySyevjInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjSetTolerance(syevjInfo_t info,
                                                          double tolerance) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjSetTolerance");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, tolerance);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjSetMaxSweeps(syevjInfo_t info,
                                                          int max_sweeps) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjSetMaxSweeps");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, max_sweeps);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjSetSortEig(syevjInfo_t info,
                                                        int sort_eig) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(syevjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjSetSortEig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, sort_eig);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjGetResidual(
    cusolverDnHandle_t handle, syevjInfo_t info, double *residual) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t,
                                                  syevjInfo_t, double *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjGetResidual");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, residual);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXsyevjGetSweeps(
    cusolverDnHandle_t handle, syevjInfo_t info, int *executed_sweeps) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, syevjInfo_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXsyevjGetSweeps");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, executed_sweeps);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsyevjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const float *A, int lda, const float *W, int *lwork,
    syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const float *, int, const float *, int *, syevjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnSsyevjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsyevjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const double *A, int lda, const double *W, int *lwork,
    syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const double *, int, const double *, int *, syevjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnDsyevjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCheevjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const cuComplex *A, int lda, const float *W, int *lwork,
    syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const cuComplex *, int, const float *, int *, syevjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnCheevjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZheevjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const cuDoubleComplex *A, int lda, const double *W, int *lwork,
    syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const cuDoubleComplex *, int, const double *, int *, syevjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnZheevjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsyevjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, float *A, int lda, float *W, float *work, int lwork, int *info,
    syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, float *,
      int, float *, float *, int, int *, syevjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsyevjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, double *A, int lda, double *W, double *work, int lwork, int *info,
    syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, double *,
      int, double *, double *, int, int *, syevjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCheevjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, cuComplex *A, int lda, float *W, cuComplex *work, int lwork,
    int *info, syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, cuComplex *,
      int, float *, cuComplex *, int, int *, syevjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZheevjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, cuDoubleComplex *A, int lda, double *W, cuDoubleComplex *work,
    int lwork, int *info, syevjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      cuDoubleComplex *, int, double *, cuDoubleComplex *, int, int *,
      syevjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsyevj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const float *A, int lda, const float *W, int *lwork,
    syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const float *, int, const float *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsyevj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const double *A, int lda, const double *W, int *lwork,
    syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const double *, int, const double *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCheevj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const cuComplex *A, int lda, const float *W, int *lwork,
    syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const cuComplex *, int, const float *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZheevj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, const cuDoubleComplex *A, int lda, const double *W, int *lwork,
    syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      const cuDoubleComplex *, int, const double *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, lwork, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsyevj(cusolverDnHandle_t handle,
                                              cusolverEigMode_t jobz,
                                              cublasFillMode_t uplo, int n,
                                              float *A, int lda, float *W,
                                              float *work, int lwork, int *info,
                                              syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, float *,
      int, float *, float *, int, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsyevj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsyevj(cusolverDnHandle_t handle,
                                              cusolverEigMode_t jobz,
                                              cublasFillMode_t uplo, int n,
                                              double *A, int lda, double *W,
                                              double *work, int lwork,
                                              int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, double *,
      int, double *, double *, int, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsyevj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCheevj(cusolverDnHandle_t handle,
                                              cusolverEigMode_t jobz,
                                              cublasFillMode_t uplo, int n,
                                              cuComplex *A, int lda, float *W,
                                              cuComplex *work, int lwork,
                                              int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int, cuComplex *,
      int, float *, cuComplex *, int, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCheevj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZheevj(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, cublasFillMode_t uplo,
    int n, cuDoubleComplex *A, int lda, double *W, cuDoubleComplex *work,
    int lwork, int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, cublasFillMode_t, int,
      cuDoubleComplex *, int, double *, cuDoubleComplex *, int, int *,
      syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZheevj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, uplo, n, A, lda, W, work, lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsygvj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const float *A, int lda, const float *B,
    int ldb, const float *W, int *lwork, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const float *, int, const float *, int,
      const float *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsygvj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const double *A, int lda, const double *B,
    int ldb, const double *W, int *lwork, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const double *, int, const double *, int,
      const double *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnChegvj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const cuComplex *A, int lda,
    const cuComplex *B, int ldb, const float *W, int *lwork,
    syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const cuComplex *, int, const cuComplex *, int,
      const float *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZhegvj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, const cuDoubleComplex *A, int lda,
    const cuDoubleComplex *B, int ldb, const double *W, int *lwork,
    syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, const cuDoubleComplex *, int,
      const cuDoubleComplex *, int, const double *, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSsygvj(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, float *A, int lda, float *B, int ldb,
    float *W, float *work, int lwork, int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, float *, int, float *, int, float *, float *, int,
      int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSsygvj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDsygvj(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, double *A, int lda, double *B, int ldb,
    double *W, double *work, int lwork, int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, double *, int, double *, int, double *, double *,
      int, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDsygvj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnChegvj(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, cuComplex *A, int lda, cuComplex *B, int ldb,
    float *W, cuComplex *work, int lwork, int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, cuComplex *, int, cuComplex *, int, float *,
      cuComplex *, int, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnChegvj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZhegvj(
    cusolverDnHandle_t handle, cusolverEigType_t itype, cusolverEigMode_t jobz,
    cublasFillMode_t uplo, int n, cuDoubleComplex *A, int lda,
    cuDoubleComplex *B, int ldb, double *W, cuDoubleComplex *work, int lwork,
    int *info, syevjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigType_t, cusolverEigMode_t,
      cublasFillMode_t, int, cuDoubleComplex *, int, cuDoubleComplex *, int,
      double *, cuDoubleComplex *, int, int *, syevjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZhegvj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, itype, jobz, uplo, n, A, lda, B, ldb, W, work, lwork,
                  info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCreateGesvdjInfo(gesvdjInfo_t *info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCreateGesvdjInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDestroyGesvdjInfo(gesvdjInfo_t info) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDestroyGesvdjInfo");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjSetTolerance(gesvdjInfo_t info,
                                                           double tolerance) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjSetTolerance");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, tolerance);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjSetMaxSweeps(gesvdjInfo_t info,
                                                           int max_sweeps) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjSetMaxSweeps");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, max_sweeps);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjSetSortEig(gesvdjInfo_t info,
                                                         int sort_svd) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(gesvdjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjSetSortEig");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(info, sort_svd);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjGetResidual(
    cusolverDnHandle_t handle, gesvdjInfo_t info, double *residual) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t,
                                                  gesvdjInfo_t, double *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjGetResidual");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, residual);
}

cusolverStatus_t CUSOLVERAPI cusolverDnXgesvdjGetSweeps(
    cusolverDnHandle_t handle, gesvdjInfo_t info, int *executed_sweeps) {
  using FuncPtr =
      cusolverStatus_t(CUSOLVERAPI *)(cusolverDnHandle_t, gesvdjInfo_t, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnXgesvdjGetSweeps");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, info, executed_sweeps);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
    const float *A, int lda, const float *S, const float *U, int ldu,
    const float *V, int ldv, int *lwork, gesvdjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, const float *, int,
      const float *, const float *, int, const float *, int, int *,
      gesvdjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnSgesvdjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
    const double *A, int lda, const double *S, const double *U, int ldu,
    const double *V, int ldv, int *lwork, gesvdjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, const double *, int,
      const double *, const double *, int, const double *, int, int *,
      gesvdjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnDgesvdjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
    const cuComplex *A, int lda, const float *S, const cuComplex *U, int ldu,
    const cuComplex *V, int ldv, int *lwork, gesvdjInfo_t params,
    int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, const cuComplex *, int,
      const float *, const cuComplex *, int, const cuComplex *, int, int *,
      gesvdjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnCgesvdjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdjBatched_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
    const cuDoubleComplex *A, int lda, const double *S,
    const cuDoubleComplex *U, int ldu, const cuDoubleComplex *V, int ldv,
    int *lwork, gesvdjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, const cuDoubleComplex *,
      int, const double *, const cuDoubleComplex *, int,
      const cuDoubleComplex *, int, int *, gesvdjInfo_t, int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("cusolverDnZgesvdjBatched_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, lwork, params,
                  batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n, float *A,
    int lda, float *S, float *U, int ldu, float *V, int ldv, float *work,
    int lwork, int *info, gesvdjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, float *, int, float *,
      float *, int, float *, int, float *, int, int *, gesvdjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvdjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
                  info, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n, double *A,
    int lda, double *S, double *U, int ldu, double *V, int ldv, double *work,
    int lwork, int *info, gesvdjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, double *, int, double *,
      double *, int, double *, int, double *, int, int *, gesvdjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvdjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
                  info, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
    cuComplex *A, int lda, float *S, cuComplex *U, int ldu, cuComplex *V,
    int ldv, cuComplex *work, int lwork, int *info, gesvdjInfo_t params,
    int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, cuComplex *, int,
      float *, cuComplex *, int, cuComplex *, int, cuComplex *, int, int *,
      gesvdjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvdjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
                  info, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdjBatched(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int m, int n,
    cuDoubleComplex *A, int lda, double *S, cuDoubleComplex *U, int ldu,
    cuDoubleComplex *V, int ldv, cuDoubleComplex *work, int lwork, int *info,
    gesvdjInfo_t params, int batchSize) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, cuDoubleComplex *, int,
      double *, cuDoubleComplex *, int, cuDoubleComplex *, int,
      cuDoubleComplex *, int, int *, gesvdjInfo_t, int);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvdjBatched");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, m, n, A, lda, S, U, ldu, V, ldv, work, lwork,
                  info, params, batchSize);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    const float *A, int lda, const float *S, const float *U, int ldu,
    const float *V, int ldv, int *lwork, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, const float *, int,
      const float *, const float *, int, const float *, int, int *,
      gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvdj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    const double *A, int lda, const double *S, const double *U, int ldu,
    const double *V, int ldv, int *lwork, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, const double *, int,
      const double *, const double *, int, const double *, int, int *,
      gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvdj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    const cuComplex *A, int lda, const float *S, const cuComplex *U, int ldu,
    const cuComplex *V, int ldv, int *lwork, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, const cuComplex *,
      int, const float *, const cuComplex *, int, const cuComplex *, int, int *,
      gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvdj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdj_bufferSize(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    const cuDoubleComplex *A, int lda, const double *S,
    const cuDoubleComplex *U, int ldu, const cuDoubleComplex *V, int ldv,
    int *lwork, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int,
      const cuDoubleComplex *, int, const double *, const cuDoubleComplex *,
      int, const cuDoubleComplex *, int, int *, gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvdj_bufferSize");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, lwork,
                  params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnSgesvdj(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    float *A, int lda, float *S, float *U, int ldu, float *V, int ldv,
    float *work, int lwork, int *info, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, float *, int,
      float *, float *, int, float *, int, float *, int, int *, gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnSgesvdj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
                  lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnDgesvdj(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    double *A, int lda, double *S, double *U, int ldu, double *V, int ldv,
    double *work, int lwork, int *info, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, double *, int,
      double *, double *, int, double *, int, double *, int, int *,
      gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnDgesvdj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
                  lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnCgesvdj(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    cuComplex *A, int lda, float *S, cuComplex *U, int ldu, cuComplex *V,
    int ldv, cuComplex *work, int lwork, int *info, gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, cuComplex *, int,
      float *, cuComplex *, int, cuComplex *, int, cuComplex *, int, int *,
      gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnCgesvdj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
                  lwork, info, params);
}

cusolverStatus_t CUSOLVERAPI cusolverDnZgesvdj(
    cusolverDnHandle_t handle, cusolverEigMode_t jobz, int econ, int m, int n,
    cuDoubleComplex *A, int lda, double *S, cuDoubleComplex *U, int ldu,
    cuDoubleComplex *V, int ldv, cuDoubleComplex *work, int lwork, int *info,
    gesvdjInfo_t params) {
  using FuncPtr = cusolverStatus_t(CUSOLVERAPI *)(
      cusolverDnHandle_t, cusolverEigMode_t, int, int, int, cuDoubleComplex *,
      int, double *, cuDoubleComplex *, int, cuDoubleComplex *, int,
      cuDoubleComplex *, int, int *, gesvdjInfo_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("cusolverDnZgesvdj");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(handle, jobz, econ, m, n, A, lda, S, U, ldu, V, ldv, work,
                  lwork, info, params);
}

}  // extern "C"
