!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! ==============================================================================
! hipfort: FORTRAN Interfaces for GPU kernels
! ==============================================================================
! Copyright (c) 2020-2022 Advanced Micro Devices, Inc. All rights reserved.
! [MITx11 License]
! 
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
! 
! The above copyright notice and this permission notice shall be included in
! all copies or substantial portions of the Software.
! 
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
! THE SOFTWARE.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          
           
module hipfort_rocsolver
  use hipfort_rocsolver_enums
  implicit none

 
  
  interface rocsolver_create_handle
    function rocsolver_create_handle_(handle) bind(c, name="rocsolver_create_handle")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_create_handle_
      type(c_ptr) :: handle
    end function

  end interface
  
  interface rocsolver_destroy_handle
    function rocsolver_destroy_handle_(handle) bind(c, name="rocsolver_destroy_handle")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_destroy_handle_
      type(c_ptr),value :: handle
    end function

  end interface
  
  interface rocsolver_set_stream
    function rocsolver_set_stream_(handle,stream) bind(c, name="rocsolver_set_stream")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_set_stream_
      type(c_ptr),value :: handle
      type(c_ptr),value :: stream
    end function

  end interface
  
  interface rocsolver_get_stream
    function rocsolver_get_stream_(handle,stream) bind(c, name="rocsolver_get_stream")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_get_stream_
      type(c_ptr),value :: handle
      type(c_ptr) :: stream
    end function

  end interface
  
  interface rocsolver_set_matrix
    function rocsolver_set_matrix_(rows,cols,elem_size,a,lda,b,ldb) bind(c, name="rocsolver_set_matrix")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_set_matrix_
      integer(c_int),value :: rows
      integer(c_int),value :: cols
      integer(c_int),value :: elem_size
      type(c_ptr),value :: a
      integer(c_int),value :: lda
      type(c_ptr),value :: b
      integer(c_int),value :: ldb
    end function

  end interface
  
  interface rocsolver_get_matrix
    function rocsolver_get_matrix_(rows,cols,elem_size,a,lda,b,ldb) bind(c, name="rocsolver_get_matrix")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_get_matrix_
      integer(c_int),value :: rows
      integer(c_int),value :: cols
      integer(c_int),value :: elem_size
      type(c_ptr),value :: a
      integer(c_int),value :: lda
      type(c_ptr),value :: b
      integer(c_int),value :: ldb
    end function

  end interface
  !>  \brief GET_VERSION_STRING Queries the library version.
  !> 
  !>     \details
  !>     @param[out]
  !>     buf         A buffer that the version string will be written into.
  !>     @param[in]
  !>     len         The size of the given buffer in bytes.
  !>
  interface rocsolver_get_version_string
    function rocsolver_get_version_string_(buf,len) bind(c, name="rocsolver_get_version_string")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_get_version_string_
      type(c_ptr),value :: buf
      integer(c_size_t),value :: len
    end function

  end interface
  !>  \brief GET_VERSION_STRING_SIZE Queries the minimum buffer size for a
  !>     successful call to \ref rocsolver_get_version_string.
  !> 
  !>     \details
  !>     @param[out]
  !>     len         pointer to size_t.\n
  !>                 The minimum length of buffer to pass to
  !>                 \ref rocsolver_get_version_string.
  !>
  interface rocsolver_get_version_string_size
    function rocsolver_get_version_string_size_(len) bind(c, name="rocsolver_get_version_string_size")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_get_version_string_size_
      type(c_ptr),value :: len
    end function

  end interface
  !>  \brief LOG_BEGIN begins a rocSOLVER multi-level logging session.
  !> 
  !>     \details
  !>     Initializes the rocSOLVER logging environment with default values (no
  !>     logging and one level depth). Default mode can be overridden by using the
  !>     environment variables ROCSOLVER_LAYER and ROCSOLVER_LEVELS.
  !> 
  !>     This function also sets the streams where the log results will be outputted.
  !>     The default is STDERR for all the modes. This default can also be overridden
  !>     using the environment variable ROCSOLVER_LOG_PATH, or specifically
  !>     ROCSOLVER_LOG_TRACE_PATH, ROCSOLVER_LOG_BENCH_PATH, and/or ROCSOLVER_LOG_PROFILE_PATH.
  interface rocsolver_log_begin
    function rocsolver_log_begin_() bind(c, name="rocsolver_log_begin")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_begin_
    end function

  end interface
  !>  \brief LOG_END ends the multi-level rocSOLVER logging session.
  !> 
  !>     \details
  !>     If applicable, this function also prints the profile logging results
  !>     before cleaning the logging environment.
  interface rocsolver_log_end
    function rocsolver_log_end_() bind(c, name="rocsolver_log_end")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_end_
    end function

  end interface
  !>  \brief LOG_SET_LAYER_MODE sets the logging mode for the rocSOLVER multi-level
  !>     logging environment.
  !> 
  !>     \details
  !>     @param[in]
  !>     layer_mode      rocblas_layer_mode_flags.\n
  !>                     Specifies the logging mode.
  interface rocsolver_log_set_layer_mode
    function rocsolver_log_set_layer_mode_(layer_mode) bind(c, name="rocsolver_log_set_layer_mode")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_set_layer_mode_
      integer(4),value :: layer_mode
    end function

  end interface
  !>  \brief LOG_SET_MAX_LEVELS sets the maximum trace log depth for the rocSOLVER
  !>     multi-level logging environment.
  !> 
  !>     \details
  !>     @param[in]
  !>     max_levels      rocblas_int. max_levels >= 1.\n
  !>                     Specifies the maximum depth at which nested function calls
  !>                     will appear in the trace and profile logs.
  interface rocsolver_log_set_max_levels
    function rocsolver_log_set_max_levels_(max_levels) bind(c, name="rocsolver_log_set_max_levels")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_set_max_levels_
      integer(c_int),value :: max_levels
    end function

  end interface
  !>  \brief LOG_RESTORE_DEFAULTS restores the default values of the rocSOLVER
  !>     multi-level logging environment.
  !> 
  !>     \details
  !>     This function sets the logging mode and maximum trace log depth to their
  !>     default values (no logging and one level depth).
  interface rocsolver_log_restore_defaults
    function rocsolver_log_restore_defaults_() bind(c, name="rocsolver_log_restore_defaults")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_restore_defaults_
    end function

  end interface
  !>  \brief LOG_WRITE_PROFILE prints the profile logging results.
  interface rocsolver_log_write_profile
    function rocsolver_log_write_profile_() bind(c, name="rocsolver_log_write_profile")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_write_profile_
    end function

  end interface
  !>  \brief LOG_FLUSH_PROFILE prints the profile logging results and clears the
  !>     profile record.
  interface rocsolver_log_flush_profile
    function rocsolver_log_flush_profile_() bind(c, name="rocsolver_log_flush_profile")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_log_flush_profile_
    end function

  end interface
  !>     \brief LACGV conjugates the complex vector x.
  !> 
  !>     \details
  !>     It conjugates the n entries of a complex vector x with increment incx.
  !> 
  !>     @param[in]
  !>     handle          rocblas_handle.
  !>     @param[in]
  !>     n               rocblas_int. n >= 0.\n
  !>                     The dimension of vector x.
  !>     @param[inout]
  !>     x               pointer to type. Array on the GPU of size at least n (size depends on the value of incx).\n
  !>                     On entry, the vector x.
  !>                     On exit, each entry is overwritten with its conjugate value.
  !>     @param[in]
  !>     incx            rocblas_int. incx != 0.\n
  !>                     The distance between two consecutive elements of x.
  !>                     If incx is negative, the elements of x are indexed in
  !>                     reverse order.
  interface rocsolver_clacgv
    function rocsolver_clacgv_(handle,n,x,incx) bind(c, name="rocsolver_clacgv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clacgv_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: x
      integer(c_int),value :: incx
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clacgv_rank_0,&
      rocsolver_clacgv_rank_1
#endif
  end interface
  
  interface rocsolver_zlacgv
    function rocsolver_zlacgv_(handle,n,x,incx) bind(c, name="rocsolver_zlacgv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: x
      integer(c_int),value :: incx
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlacgv_rank_0,&
      rocsolver_zlacgv_rank_1
#endif
  end interface
  !>     \brief LASWP performs a series of row interchanges on the matrix A.
  !> 
  !>     \details
  !>     Row interchanges are done one by one. If \f$\text{ipiv}[k_1 + (j - k_1) \cdot \text{abs}(\text{incx})] = r\f$, then the j-th row of A
  !>     will be interchanged with the r-th row of A, for \f$j = k_1,k_1+1,\dots,k_2\f$. Indices \f$k_1\f$ and \f$k_2\f$ are 1-based indices.
  !> 
  !>     @param[in]
  !>     handle          rocblas_handle.
  !>     @param[in]
  !>     n               rocblas_int. n >= 0.\n
  !>                     The number of columns of the matrix A.
  !>     @param[inout]
  !>     A               pointer to type. Array on the GPU of dimension lda*n. \n
  !>                     On entry, the matrix to which the row
  !>                     interchanges will be applied. On exit, the resulting permuted matrix.
  !>     @param[in]
  !>     lda             rocblas_int. lda > 0.\n
  !>                     The leading dimension of the array A.
  !>     @param[in]
  !>     k1              rocblas_int. k1 > 0.\n
  !>                     The k_1 index. It is the first element of ipiv for which a row interchange will
  !>                     be done. This is a 1-based index.
  !>     @param[in]
  !>     k2              rocblas_int. k2 > k1 > 0.\n
  !>                     The k_2 index. k_2 - k_1 + 1 is the number of elements of ipiv for which a row
  !>                     interchange will be done. This is a 1-based index.
  !>     @param[in]
  !>     ipiv            pointer to rocblas_int. Array on the GPU of dimension at least k_1 + (k_2 - k_1)*abs(incx).\n
  !>                     The vector of pivot indices. Only the elements in positions
  !>                     k_1 through k_1 + (k_2 - k_1)*abs(incx) of this vector are accessed.
  !>                     Elements of ipiv are considered 1-based.
  !>     @param[in]
  !>     incx            rocblas_int. incx != 0.\n
  !>                     The distance between successive values of ipiv.  If incx
  !>                     is negative, the pivots are applied in reverse order.
  interface rocsolver_slaswp
    function rocsolver_slaswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_slaswp")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slaswp_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int),value :: k1
      integer(c_int),value :: k2
      type(c_ptr),value :: ipiv
      integer(c_int),value :: incx
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slaswp_full_rank,&
      rocsolver_slaswp_rank_0,&
      rocsolver_slaswp_rank_1
#endif
  end interface
  
  interface rocsolver_dlaswp
    function rocsolver_dlaswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_dlaswp")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int),value :: k1
      integer(c_int),value :: k2
      type(c_ptr),value :: ipiv
      integer(c_int),value :: incx
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlaswp_full_rank,&
      rocsolver_dlaswp_rank_0,&
      rocsolver_dlaswp_rank_1
#endif
  end interface
  
  interface rocsolver_claswp
    function rocsolver_claswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_claswp")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_claswp_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int),value :: k1
      integer(c_int),value :: k2
      type(c_ptr),value :: ipiv
      integer(c_int),value :: incx
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_claswp_full_rank,&
      rocsolver_claswp_rank_0,&
      rocsolver_claswp_rank_1
#endif
  end interface
  
  interface rocsolver_zlaswp
    function rocsolver_zlaswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_zlaswp")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int),value :: k1
      integer(c_int),value :: k2
      type(c_ptr),value :: ipiv
      integer(c_int),value :: incx
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlaswp_full_rank,&
      rocsolver_zlaswp_rank_0,&
      rocsolver_zlaswp_rank_1
#endif
  end interface
  !>     \brief LARFG generates a Householder reflector H of order n.
  !> 
  !>     \details
  !>     The reflector H is such that
  !> 
  !>     \f[
  !>         H'\left[\begin{array}{c}
  !>         \text{alpha}\newline
  !>
  !>         x
  !>         \end{array}\right]=\left[\begin{array}{c}
  !>         \text{beta}\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where x is an n-1 vector, and alpha and beta are scalars. Matrix H can be
  !>     generated as
  !> 
  !>     \f[
  !>         H = I - \text{tau}\left[\begin{array}{c}
  !>         1\newline
  !>
  !>         v
  !>         \end{array}\right]\left[\begin{array}{cc}
  !>         1 & v'
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where v is an n-1 vector, and tau is a scalar known as the Householder scalar. The vector
  !> 
  !>     \f[
  !>         \bar{v}=\left[\begin{array}{c}
  !>         1\newline
  !>
  !>         v
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     is the Householder vector associated with the reflection.
  !> 
  !>     \note
  !>     The matrix H is orthogonal/unitary (i.e. \f$H'H=HH'=I\f$). It is symmetric when real (i.e. \f$H^T=H\f$), but not Hermitian when complex
  !>     (i.e. \f$H^H\neq H\f$ in general).
  !> 
  !>     @param[in]
  !>     handle          rocblas_handle.
  !>     @param[in]
  !>     n               rocblas_int. n >= 0.\n
  !>                     The order (size) of reflector H.
  !>     @param[inout]
  !>     alpha           pointer to type. A scalar on the GPU.\n
  !>                     On entry, the scalar alpha.
  !>                     On exit, it is overwritten with beta.
  !>     @param[inout]
  !>     x               pointer to type. Array on the GPU of size at least n-1 (size depends on the value of incx).\n
  !>                     On entry, the vector x,
  !>                     On exit, it is overwritten with vector v.
  !>     @param[in]
  !>     incx            rocblas_int. incx > 0.\n
  !>                     The distance between two consecutive elements of x.
  !>     @param[out]
  !>     tau             pointer to type. A scalar on the GPU.\n
  !>                     The Householder scalar tau.
  !>
  interface rocsolver_slarfg
    function rocsolver_slarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_slarfg")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfg_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      real(c_float) :: alpha
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      real(c_float) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slarfg_rank_0,&
      rocsolver_slarfg_rank_1
#endif
  end interface
  
  interface rocsolver_dlarfg
    function rocsolver_dlarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_dlarfg")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      real(c_double) :: alpha
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      real(c_double) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlarfg_rank_0,&
      rocsolver_dlarfg_rank_1
#endif
  end interface
  
  interface rocsolver_clarfg
    function rocsolver_clarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_clarfg")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfg_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      complex(c_float_complex) :: alpha
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      complex(c_float_complex) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clarfg_rank_0,&
      rocsolver_clarfg_rank_1
#endif
  end interface
  
  interface rocsolver_zlarfg
    function rocsolver_zlarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_zlarfg")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      complex(c_double_complex) :: alpha
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      complex(c_double_complex) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlarfg_rank_0,&
      rocsolver_zlarfg_rank_1
#endif
  end interface
  !>     \brief LARFT generates the triangular factor T of a block reflector H of
  !>     order n.
  !> 
  !>     \details
  !>     The block reflector H is defined as the product of k Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H = H_1H_2\cdots H_k & \: \text{if direct indicates forward direction, or} \newline
  !>
  !>         H = H_k\cdots H_2H_1 & \: \text{if direct indicates backward direction}
  !>         \end{array}
  !>     \f]
  !> 
  !>     The triangular factor T is upper triangular in the forward direction and lower triangular in the backward direction.
  !>     If storev is column-wise, then
  !> 
  !>     \f[
  !>         H = I - VTV'
  !>     \f]
  !> 
  !>     where the i-th column of matrix V contains the Householder vector associated with \f$H_i\f$. If storev is row-wise, then
  !> 
  !>     \f[
  !>         H = I - V'TV
  !>     \f]
  !> 
  !>     where the i-th row of matrix V contains the Householder vector associated with \f$H_i\f$.
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     direct              rocblas_direct.\n
  !>                         Specifies the direction in which the Householder matrices are applied.
  !>     @param[in]
  !>     storev              rocblas_storev.\n
  !>                         Specifies how the Householder vectors are stored in matrix V.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         The order (size) of the block reflector.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 1.\n
  !>                         The number of Householder matrices forming H.
  !>     @param[in]
  !>     V                   pointer to type. Array on the GPU of size ldv*k if column-wise, or ldv*n if row-wise.\n
  !>                         The matrix of Householder vectors.
  !>     @param[in]
  !>     ldv                 rocblas_int. ldv >= n if column-wise, or ldv >= k if row-wise.\n
  !>                         Leading dimension of V.
  !>     @param[in]
  !>     tau                 pointer to type. Array of k scalars on the GPU.\n
  !>                         The vector of all the Householder scalars.
  !>     @param[out]
  !>     T                   pointer to type. Array on the GPU of dimension ldt*k.\n
  !>                         The triangular factor. T is upper triangular if direct indicates forward direction, otherwise it is
  !>                         lower triangular. The rest of the array is not used.
  !>     @param[in]
  !>     ldt                 rocblas_int. ldt >= k.\n
  !>                         The leading dimension of T.
  !>
  interface rocsolver_slarft
    function rocsolver_slarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) bind(c, name="rocsolver_slarft")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarft_
      type(c_ptr),value :: handle
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      real(c_float) :: tau
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slarft_full_rank,&
      rocsolver_slarft_rank_0,&
      rocsolver_slarft_rank_1
#endif
  end interface
  
  interface rocsolver_dlarft
    function rocsolver_dlarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) bind(c, name="rocsolver_dlarft")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarft_
      type(c_ptr),value :: handle
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      real(c_double) :: tau
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlarft_full_rank,&
      rocsolver_dlarft_rank_0,&
      rocsolver_dlarft_rank_1
#endif
  end interface
  
  interface rocsolver_clarft
    function rocsolver_clarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) bind(c, name="rocsolver_clarft")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarft_
      type(c_ptr),value :: handle
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      complex(c_float_complex) :: tau
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clarft_full_rank,&
      rocsolver_clarft_rank_0,&
      rocsolver_clarft_rank_1
#endif
  end interface
  
  interface rocsolver_zlarft
    function rocsolver_zlarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) bind(c, name="rocsolver_zlarft")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarft_
      type(c_ptr),value :: handle
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      complex(c_double_complex) :: tau
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlarft_full_rank,&
      rocsolver_zlarft_rank_0,&
      rocsolver_zlarft_rank_1
#endif
  end interface
  !>     \brief LARF applies a Householder reflector H to a general matrix A.
  !> 
  !>     \details
  !>     The Householder reflector H, of order m or n, is to be applied to an m-by-n matrix A
  !>     from the left or the right, depending on the value of side. H is given by
  !> 
  !>     \f[
  !>         H = I - \text{alpha}\cdot xx'
  !>     \f]
  !> 
  !>     where alpha is the Householder scalar and x is a Householder vector. H is never actually computed.
  !> 
  !>     @param[in]
  !>     handle          rocblas_handle.
  !>     @param[in]
  !>     side            rocblas_side.\n
  !>                     Determines whether H is applied from the left or the right.
  !>     @param[in]
  !>     m               rocblas_int. m >= 0.\n
  !>                     Number of rows of A.
  !>     @param[in]
  !>     n               rocblas_int. n >= 0.\n
  !>                     Number of columns of A.
  !>     @param[in]
  !>     x               pointer to type. Array on the GPU of
  !>                     size at least 1 + (m-1)*abs(incx) if left side, or
  !>                     at least 1 + (n-1)*abs(incx) if right side.\n
  !>                     The Householder vector x.
  !>     @param[in]
  !>     incx            rocblas_int. incx != 0.\n
  !>                     Distance between two consecutive elements of x.
  !>                     If incx < 0, the elements of x are indexed in reverse order.
  !>     @param[in]
  !>     alpha           pointer to type. A scalar on the GPU.\n
  !>                     The Householder scalar. If alpha = 0, then H = I (A will remain the same; x is never used)
  !>     @param[inout]
  !>     A               pointer to type. Array on the GPU of size lda*n.\n
  !>                     On entry, the matrix A. On exit, it is overwritten with
  !>                     H*A (or A*H).
  !>     @param[in]
  !>     lda             rocblas_int. lda >= m.\n
  !>                     Leading dimension of A.
  !>
  interface rocsolver_slarf
    function rocsolver_slarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_slarf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      real(c_float) :: alpha
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slarf_full_rank,&
      rocsolver_slarf_rank_0,&
      rocsolver_slarf_rank_1
#endif
  end interface
  
  interface rocsolver_dlarf
    function rocsolver_dlarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_dlarf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      real(c_double) :: alpha
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlarf_full_rank,&
      rocsolver_dlarf_rank_0,&
      rocsolver_dlarf_rank_1
#endif
  end interface
  
  interface rocsolver_clarf
    function rocsolver_clarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_clarf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      complex(c_float_complex) :: alpha
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clarf_full_rank,&
      rocsolver_clarf_rank_0,&
      rocsolver_clarf_rank_1
#endif
  end interface
  
  interface rocsolver_zlarf
    function rocsolver_zlarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_zlarf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: x
      integer(c_int),value :: incx
      complex(c_double_complex) :: alpha
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlarf_full_rank,&
      rocsolver_zlarf_rank_0,&
      rocsolver_zlarf_rank_1
#endif
  end interface
  !>     \brief LARFB applies a block reflector H to a general m-by-n matrix A.
  !> 
  !>     \details
  !>     The block reflector H is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         HA & \: \text{(No transpose from the left),}\newline
  !>
  !>         H'A & \:  \text{(Transpose or conjugate transpose from the left),}\newline
  !>
  !>         AH & \: \text{(No transpose from the right), or}\newline
  !>
  !>         AH' & \: \text{(Transpose or conjugate transpose from the right).}
  !>         \end{array}
  !>     \f]
  !> 
  !>     The block reflector H is defined as the product of k Householder matrices as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H = H_1H_2\cdots H_k & \: \text{if direct indicates forward direction, or} \newline
  !>
  !>         H = H_k\cdots H_2H_1 & \: \text{if direct indicates backward direction}
  !>         \end{array}
  !>     \f]
  !> 
  !>     H is never stored. It is calculated as
  !> 
  !>     \f[
  !>         H = I - VTV'
  !>     \f]
  !> 
  !>     where the i-th column of matrix V contains the Householder vector associated with \f$H_i\f$, if storev is column-wise; or
  !> 
  !>     \f[
  !>         H = I - V'TV
  !>     \f]
  !> 
  !>     where the i-th row of matrix V contains the Householder vector associated with \f$H_i\f$, if storev is row-wise.
  !>     T is the associated triangular factor as computed by \ref rocsolver_slarft "LARFT".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply H.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the block reflector or its transpose/conjugate transpose is to be applied.
  !>     @param[in]
  !>     direct              rocblas_direct.\n
  !>                         Specifies the direction in which the Householder matrices are to be applied to generate H.
  !>     @param[in]
  !>     storev              rocblas_storev.\n
  !>                         Specifies how the Householder vectors are stored in matrix V.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix A.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix A.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 1.\n
  !>                         The number of Householder matrices.
  !>     @param[in]
  !>     V                   pointer to type. Array on the GPU of size ldv*k if column-wise, ldv*n if row-wise and applying from the right,
  !>                         or ldv*m if row-wise and applying from the left.\n
  !>                         The matrix of Householder vectors.
  !>     @param[in]
  !>     ldv                 rocblas_int. ldv >= k if row-wise, ldv >= m if column-wise and applying from the left, or ldv >= n if
  !>                         column-wise and applying from the right.\n
  !>                         Leading dimension of V.
  !>     @param[in]
  !>     T                   pointer to type. Array on the GPU of dimension ldt*k.\n
  !>                         The triangular factor of the block reflector.
  !>     @param[in]
  !>     ldt                 rocblas_int. ldt >= k.\n
  !>                         The leading dimension of T.
  !>     @param[inout]
  !>     A                   pointer to type. Array on the GPU of size lda*n.\n
  !>                         On entry, the matrix A. On exit, it is overwritten with
  !>                         H*A, A*H, H'*A, or A*H'.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m.\n
  !>                         Leading dimension of A.
  !>
  interface rocsolver_slarfb
    function rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) bind(c, name="rocsolver_slarfb")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfb_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slarfb_full_rank,&
      rocsolver_slarfb_rank_0,&
      rocsolver_slarfb_rank_1
#endif
  end interface
  
  interface rocsolver_dlarfb
    function rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) bind(c, name="rocsolver_dlarfb")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlarfb_full_rank,&
      rocsolver_dlarfb_rank_0,&
      rocsolver_dlarfb_rank_1
#endif
  end interface
  
  interface rocsolver_clarfb
    function rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) bind(c, name="rocsolver_clarfb")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfb_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clarfb_full_rank,&
      rocsolver_clarfb_rank_0,&
      rocsolver_clarfb_rank_1
#endif
  end interface
  
  interface rocsolver_zlarfb
    function rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) bind(c, name="rocsolver_zlarfb")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(kind(rocblas_forward_direction)),value :: myDirect
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: T
      integer(c_int),value :: ldt
      type(c_ptr),value :: A
      integer(c_int),value :: lda
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlarfb_full_rank,&
      rocsolver_zlarfb_rank_0,&
      rocsolver_zlarfb_rank_1
#endif
  end interface
  !>     \brief LABRD computes the bidiagonal form of the first k rows and columns of
  !>     a general m-by-n matrix A, as well as the matrices X and Y needed to reduce
  !>     the remaining part of A.
  !> 
  !>     \details
  !>     The reduced form is given by:
  !> 
  !>     \f[
  !>         B = Q'AP
  !>     \f]
  !> 
  !>     where the leading k-by-k block of B is upper bidiagonal if m >= n, or lower bidiagonal if m < n. Q and
  !>     P are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_k, & \text{and} \newline
  !>
  !>         P = G_1G_2\cdots G_k.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ and \f$G_i\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_i = I - \text{tauq}[i]\cdot v_iv_i', & \text{and} \newline
  !>
  !>         G_i = I - \text{taup}[i]\cdot u_iu_i'.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i]=1\f$;
  !>     while the first i elements of the Householder vector \f$u_i\f$ are zero, and  \f$u_i[i+1]=1\f$.
  !>     If m < n, the first i elements of the Householder vector  \f$v_i\f$ are zero, and  \f$v_i[i+1]=1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i]=1\f$.
  !> 
  !>     The unreduced part of the matrix A can be updated using the block update
  !> 
  !>     \f[
  !>         A = A - VY' - XU'
  !>     \f]
  !> 
  !>     where V and U are the m-by-k and n-by-k matrices formed with the vectors \f$v_i\f$ and \f$u_i\f$, respectively.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[in]
  !>     k         rocblas_int. min(m,n) >= k >= 0.\n
  !>               The number of leading rows and columns of matrix A that will be reduced.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be reduced.
  !>               On exit, the first k elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n), contain the bidiagonal form B.
  !>               If m >= n, the elements below the diagonal of the first k columns are the possibly non-zero elements
  !>               of the Householder vectors associated with Q, while the elements above the
  !>               superdiagonal of the first k rows are the n - i - 1 possibly non-zero elements of the Householder vectors related to P.
  !>               If m < n, the elements below the subdiagonal of the first k columns are the m - i - 1 possibly non-zero
  !>               elements of the Householder vectors related to Q, while the elements above the
  !>               diagonal of the first k rows are the n - i possibly non-zero elements of the vectors associated with P.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               specifies the leading dimension of A.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension k.\n
  !>               The diagonal elements of B.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension k.\n
  !>               The off-diagonal elements of B.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU of dimension k.\n
  !>               The Householder scalars associated with matrix Q.
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU of dimension k.\n
  !>               The Householder scalars associated with matrix P.
  !>     @param[out]
  !>     X         pointer to type. Array on the GPU of dimension ldx*k.\n
  !>               The m-by-k matrix needed to update the unreduced part of A.
  !>     @param[in]
  !>     ldx       rocblas_int. ldx >= m.\n
  !>               The leading dimension of X.
  !>     @param[out]
  !>     Y         pointer to type. Array on the GPU of dimension ldy*k.\n
  !>               The n-by-k matrix needed to update the unreduced part of A.
  !>     @param[in]
  !>     ldy       rocblas_int. ldy >= n.\n
  !>               The leading dimension of Y.
  !>
  interface rocsolver_slabrd
    function rocsolver_slabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) bind(c, name="rocsolver_slabrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slabrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
      type(c_ptr),value :: X
      integer(c_int),value :: ldx
      type(c_ptr),value :: Y
      integer(c_int),value :: ldy
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slabrd_full_rank,&
      rocsolver_slabrd_rank_0,&
      rocsolver_slabrd_rank_1
#endif
  end interface
  
  interface rocsolver_dlabrd
    function rocsolver_dlabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) bind(c, name="rocsolver_dlabrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
      type(c_ptr),value :: X
      integer(c_int),value :: ldx
      type(c_ptr),value :: Y
      integer(c_int),value :: ldy
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlabrd_full_rank,&
      rocsolver_dlabrd_rank_0,&
      rocsolver_dlabrd_rank_1
#endif
  end interface
  
  interface rocsolver_clabrd
    function rocsolver_clabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) bind(c, name="rocsolver_clabrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clabrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
      type(c_ptr),value :: X
      integer(c_int),value :: ldx
      type(c_ptr),value :: Y
      integer(c_int),value :: ldy
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clabrd_full_rank,&
      rocsolver_clabrd_rank_0,&
      rocsolver_clabrd_rank_1
#endif
  end interface
  
  interface rocsolver_zlabrd
    function rocsolver_zlabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) bind(c, name="rocsolver_zlabrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
      type(c_ptr),value :: X
      integer(c_int),value :: ldx
      type(c_ptr),value :: Y
      integer(c_int),value :: ldy
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlabrd_full_rank,&
      rocsolver_zlabrd_rank_0,&
      rocsolver_zlabrd_rank_1
#endif
  end interface
  !>     \brief LATRD computes the tridiagonal form of k rows and columns of
  !>     a symmetric/hermitian matrix A, as well as the matrix W needed to update
  !>     the remaining part of A.
  !> 
  !>     \details
  !>     The reduced form is given by:
  !> 
  !>     \f[
  !>         T = Q'AQ
  !>     \f]
  !> 
  !>     If uplo is lower, the first k rows and columns of T form the tridiagonal block. If uplo is upper, then the last
  !>     k rows and columns of T form the tridiagonal block. Q is an orthogonal/unitary matrix represented as the
  !>     product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_k & \text{if uplo indicates lower, or}\newline
  !>
  !>         Q = H_nH_{n-1}\cdots H_{n-k+1} & \text{if uplo is upper}.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{tau}[i]\cdot v_iv_i'
  !>     \f]
  !> 
  !>     where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If uplo is upper,
  !>     the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     The unreduced part of the matrix A can be updated using a rank update of the form:
  !> 
  !>     \f[
  !>         A = A - VW' - WV'
  !>     \f]
  !> 
  !>     where V is the n-by-k matrix formed by the vectors \f$v_i\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[in]
  !>     k         rocblas_int. 0 <= k <= n.\n
  !>               The number of rows and columns of the matrix A to be reduced.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the n-by-n matrix to be reduced.
  !>               On exit, if uplo is lower, the first k columns have been reduced to tridiagonal form
  !>               (given in the diagonal elements of A and the array E), the elements below the diagonal
  !>               contain the possibly non-zero entries of the Householder vectors associated with Q, stored as columns.
  !>               If uplo is upper, the last k columns have been reduced to tridiagonal form
  !>               (given in the diagonal elements of A and the array E), the elements above the diagonal
  !>               contain the possibly non-zero entries of the Householder vectors associated with Q, stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension n-1.\n
  !>               If upper (lower), the last (first) k elements of E are the off-diagonal elements of the
  !>               computed tridiagonal block.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU of dimension n-1.\n
  !>               If upper (lower), the last (first) k elements of tau are the Householder scalars related to Q.
  !>     @param[out]
  !>     W         pointer to type. Array on the GPU of dimension ldw*k.\n
  !>               The n-by-k matrix needed to update the unreduced part of A.
  !>     @param[in]
  !>     ldw       rocblas_int. ldw >= n.\n
  !>               The leading dimension of W.
  interface rocsolver_slatrd
    function rocsolver_slatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_slatrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slatrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: E
      real(c_float) :: tau
      type(c_ptr),value :: W
      integer(c_int),value :: ldw
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slatrd_full_rank,&
      rocsolver_slatrd_rank_0,&
      rocsolver_slatrd_rank_1
#endif
  end interface
  
  interface rocsolver_dlatrd
    function rocsolver_dlatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_dlatrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: E
      real(c_double) :: tau
      type(c_ptr),value :: W
      integer(c_int),value :: ldw
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlatrd_full_rank,&
      rocsolver_dlatrd_rank_0,&
      rocsolver_dlatrd_rank_1
#endif
  end interface
  
  interface rocsolver_clatrd
    function rocsolver_clatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_clatrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clatrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: E
      complex(c_float_complex) :: tau
      type(c_ptr),value :: W
      integer(c_int),value :: ldw
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clatrd_full_rank,&
      rocsolver_clatrd_rank_0,&
      rocsolver_clatrd_rank_1
#endif
  end interface
  
  interface rocsolver_zlatrd
    function rocsolver_zlatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_zlatrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: E
      complex(c_double_complex) :: tau
      type(c_ptr),value :: W
      integer(c_int),value :: ldw
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlatrd_full_rank,&
      rocsolver_zlatrd_rank_0,&
      rocsolver_zlatrd_rank_1
#endif
  end interface
  !>     \brief LASYF computes a partial factorization of a symmetric matrix \f$A\f$
  !>     using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     The partial factorization has the form
  !> 
  !>     \f[
  !>         A = \left[ \begin{array}{cc}
  !>         I & U_{12} \newline
  !>
  !>         0 & U_{22}
  !>         \end{array} \right] \left[ \begin{array}{cc}
  !>         A_{11} & 0 \newline
  !>
  !>         0 & D
  !>         \end{array} \right] \left[ \begin{array}{cc}
  !>         I & 0 \newline
  !>
  !>         U_{12}^T & U_{22}^T
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     or
  !> 
  !>     \f[
  !>         A = \left[ \begin{array}{cc}
  !>         L_{11} & 0 \newline
  !>
  !>         L_{21} & I
  !>         \end{array} \right] \left[ \begin{array}{cc}
  !>         D & 0 \newline
  !>
  !>         0 & A_{22}
  !>         \end{array} \right] \left[ \begin{array}{cc}
  !>         L_{11}^T & L_{21}^T \newline
  !>
  !>         0 & I
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     depending on the value of uplo. The order of the block diagonal matrix \f$D\f$
  !>     is either \f$nb\f$ or \f$nb-1\f$, and is returned in the argument \f$kb\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[in]
  !>     nb        rocblas_int. 2 <= nb <= n.\n
  !>               The number of columns of A to be factored.
  !>     @param[out]
  !>     kb        pointer to a rocblas_int on the GPU.\n
  !>               The number of columns of A that were actually factored (either nb or
  !>               nb-1).
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrix A to be factored.
  !>               On exit, the partially factored matrix.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               If uplo is upper, then only the last kb elements of ipiv will be
  !>               set. For n - kb < k <= n, if ipiv[k] > 0 then rows and columns k
  !>               and ipiv[k] were interchanged and D[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv[k] = ipiv[k-1] < 0, then rows and columns k-1
  !>               and -ipiv[k] were interchanged and D[k-1,k-1] to D[k,k] is a 2-by-2
  !>               diagonal block.
  !>               If uplo is lower, then only the first kb elements of ipiv will be
  !>               set. For 1 <= k <= kb, if ipiv[k] > 0 then rows and columns k
  !>               and ipiv[k] were interchanged and D[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv[k] = ipiv[k+1] < 0, then rows and columns k+1
  !>               and -ipiv[k] were interchanged and D[k,k] to D[k+1,k+1] is a 2-by-2
  !>               diagonal block.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info[i] = j > 0, D is singular. D[j,j] is the first diagonal zero.
  interface rocsolver_slasyf
    function rocsolver_slasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) bind(c, name="rocsolver_slasyf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slasyf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nb
      type(c_ptr),value :: kb
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_slasyf_full_rank,&
      rocsolver_slasyf_rank_0,&
      rocsolver_slasyf_rank_1
#endif
  end interface
  
  interface rocsolver_dlasyf
    function rocsolver_dlasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dlasyf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nb
      type(c_ptr),value :: kb
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dlasyf_full_rank,&
      rocsolver_dlasyf_rank_0,&
      rocsolver_dlasyf_rank_1
#endif
  end interface
  
  interface rocsolver_clasyf
    function rocsolver_clasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) bind(c, name="rocsolver_clasyf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clasyf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nb
      type(c_ptr),value :: kb
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_clasyf_full_rank,&
      rocsolver_clasyf_rank_0,&
      rocsolver_clasyf_rank_1
#endif
  end interface
  
  interface rocsolver_zlasyf
    function rocsolver_zlasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zlasyf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nb
      type(c_ptr),value :: kb
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zlasyf_full_rank,&
      rocsolver_zlasyf_rank_0,&
      rocsolver_zlasyf_rank_1
#endif
  end interface
  !>     \brief ORG2R generates an m-by-n Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first n columns of the product of k Householder
  !>     reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k.
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the Householder vectors in the first k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  interface rocsolver_sorg2r
    function rocsolver_sorg2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorg2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorg2r_full_rank,&
      rocsolver_sorg2r_rank_0,&
      rocsolver_sorg2r_rank_1
#endif
  end interface
  
  interface rocsolver_dorg2r
    function rocsolver_dorg2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorg2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorg2r_full_rank,&
      rocsolver_dorg2r_rank_0,&
      rocsolver_dorg2r_rank_1
#endif
  end interface
  !>     \brief UNG2R generates an m-by-n complex Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first n columns of the product of k Householder
  !>     reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the Householder vectors in the first k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  interface rocsolver_cung2r
    function rocsolver_cung2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cung2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2r_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cung2r_full_rank,&
      rocsolver_cung2r_rank_0,&
      rocsolver_cung2r_rank_1
#endif
  end interface
  
  interface rocsolver_zung2r
    function rocsolver_zung2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zung2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2r_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zung2r_full_rank,&
      rocsolver_zung2r_rank_0,&
      rocsolver_zung2r_rank_1
#endif
  end interface
  !>     \brief ORGQR generates an m-by-n Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first n columns of the product of k Householder
  !>     reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the Householder vectors in the first k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  interface rocsolver_sorgqr
    function rocsolver_sorgqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorgqr_full_rank,&
      rocsolver_sorgqr_rank_0,&
      rocsolver_sorgqr_rank_1
#endif
  end interface
  
  interface rocsolver_dorgqr
    function rocsolver_dorgqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorgqr_full_rank,&
      rocsolver_dorgqr_rank_0,&
      rocsolver_dorgqr_rank_1
#endif
  end interface
  !>     \brief UNGQR generates an m-by-n complex Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first n columns of the product of k Householder
  !>     reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the Householder vectors in the first k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  interface rocsolver_cungqr
    function rocsolver_cungqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungqr_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cungqr_full_rank,&
      rocsolver_cungqr_rank_0,&
      rocsolver_cungqr_rank_1
#endif
  end interface
  
  interface rocsolver_zungqr
    function rocsolver_zungqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungqr_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zungqr_full_rank,&
      rocsolver_zungqr_rank_0,&
      rocsolver_zungqr_rank_1
#endif
  end interface
  !>     \brief ORGL2 generates an m-by-n Matrix Q with orthonormal rows.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first m rows of the product of k Householder
  !>     reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. 0 <= m <= n.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= m.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the Householder vectors in the first k rows.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  interface rocsolver_sorgl2
    function rocsolver_sorgl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgl2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorgl2_full_rank,&
      rocsolver_sorgl2_rank_0,&
      rocsolver_sorgl2_rank_1
#endif
  end interface
  
  interface rocsolver_dorgl2
    function rocsolver_dorgl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgl2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorgl2_full_rank,&
      rocsolver_dorgl2_rank_0,&
      rocsolver_dorgl2_rank_1
#endif
  end interface
  !>     \brief UNGL2 generates an m-by-n complex Matrix Q with orthonormal rows.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first m rows of the product of k Householder
  !>     reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_k^HH_{k-1}^H\cdots H_1^H
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. 0 <= m <= n.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= m.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the Householder vectors in the first k rows.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  interface rocsolver_cungl2
    function rocsolver_cungl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungl2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungl2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cungl2_full_rank,&
      rocsolver_cungl2_rank_0,&
      rocsolver_cungl2_rank_1
#endif
  end interface
  
  interface rocsolver_zungl2
    function rocsolver_zungl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungl2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungl2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zungl2_full_rank,&
      rocsolver_zungl2_rank_0,&
      rocsolver_zungl2_rank_1
#endif
  end interface
  !>     \brief ORGLQ generates an m-by-n Matrix Q with orthonormal rows.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first m rows of the product of k Householder
  !>     reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. 0 <= m <= n.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= m.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the Householder vectors in the first k rows.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  interface rocsolver_sorglq
    function rocsolver_sorglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorglq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorglq_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorglq_full_rank,&
      rocsolver_sorglq_rank_0,&
      rocsolver_sorglq_rank_1
#endif
  end interface
  
  interface rocsolver_dorglq
    function rocsolver_dorglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorglq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorglq_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorglq_full_rank,&
      rocsolver_dorglq_rank_0,&
      rocsolver_dorglq_rank_1
#endif
  end interface
  !>     \brief UNGLQ generates an m-by-n complex Matrix Q with orthonormal rows.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the first m rows of the product of k Householder
  !>     reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_k^HH_{k-1}^H\cdots H_1^H
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. 0 <= m <= n.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= m.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the Householder vectors in the first k rows.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  interface rocsolver_cunglq
    function rocsolver_cunglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cunglq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunglq_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunglq_full_rank,&
      rocsolver_cunglq_rank_0,&
      rocsolver_cunglq_rank_1
#endif
  end interface
  
  interface rocsolver_zunglq
    function rocsolver_zunglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zunglq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunglq_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunglq_full_rank,&
      rocsolver_zunglq_rank_0,&
      rocsolver_zunglq_rank_1
#endif
  end interface
  !>     \brief ORG2L generates an m-by-n Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the last n columns of the product of k
  !>     Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the Householder vectors in the last k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF".
  interface rocsolver_sorg2l
    function rocsolver_sorg2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorg2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorg2l_full_rank,&
      rocsolver_sorg2l_rank_0,&
      rocsolver_sorg2l_rank_1
#endif
  end interface
  
  interface rocsolver_dorg2l
    function rocsolver_dorg2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorg2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorg2l_full_rank,&
      rocsolver_dorg2l_rank_0,&
      rocsolver_dorg2l_rank_1
#endif
  end interface
  !>     \brief UNG2L generates an m-by-n complex Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the last n columns of the product of k
  !>     Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the Householder vectors in the last k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF".
  interface rocsolver_cung2l
    function rocsolver_cung2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cung2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2l_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cung2l_full_rank,&
      rocsolver_cung2l_rank_0,&
      rocsolver_cung2l_rank_1
#endif
  end interface
  
  interface rocsolver_zung2l
    function rocsolver_zung2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zung2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2l_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zung2l_full_rank,&
      rocsolver_zung2l_rank_0,&
      rocsolver_zung2l_rank_1
#endif
  end interface
  !>     \brief ORGQL generates an m-by-n Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the last n column of the product of k Householder
  !>     reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the Householder vectors in the last k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF".
  interface rocsolver_sorgql
    function rocsolver_sorgql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgql_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorgql_full_rank,&
      rocsolver_sorgql_rank_0,&
      rocsolver_sorgql_rank_1
#endif
  end interface
  
  interface rocsolver_dorgql
    function rocsolver_dorgql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgql_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorgql_full_rank,&
      rocsolver_dorgql_rank_0,&
      rocsolver_dorgql_rank_1
#endif
  end interface
  !>     \brief UNGQL generates an m-by-n complex Matrix Q with orthonormal columns.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is defined as the last n columns of the product of k
  !>     Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>     @param[in]
  !>     n           rocblas_int. 0 <= n <= m.\n
  !>                 The number of columns of the matrix Q.
  !>     @param[in]
  !>     k           rocblas_int. 0 <= k <= n.\n
  !>                 The number of Householder reflectors.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the Householder vectors in the last k columns.
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension at least k.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF".
  interface rocsolver_cungql
    function rocsolver_cungql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungql_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cungql_full_rank,&
      rocsolver_cungql_rank_0,&
      rocsolver_cungql_rank_1
#endif
  end interface
  
  interface rocsolver_zungql
    function rocsolver_zungql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungql_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zungql_full_rank,&
      rocsolver_zungql_rank_0,&
      rocsolver_zungql_rank_1
#endif
  end interface
  !>     \brief ORGBR generates an m-by-n Matrix Q with orthonormal rows or columns.
  !> 
  !>     \details
  !>     If storev is column-wise, then the matrix Q has orthonormal columns. If m >= k, Q is defined as the first
  !>     n columns of the product of k Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     If m < k, Q is defined as the product of Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{m-1}
  !>     \f]
  !> 
  !>     On the other hand, if storev is row-wise, then the matrix Q has orthonormal rows. If n > k, Q is defined as the
  !>     first m rows of the product of k Householder reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     If n <= k, Q is defined as the product of Householder reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_{n-1}H_{n-2}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgebrd "GEBRD" in its arguments A and tauq or taup.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     storev      rocblas_storev.\n
  !>                 Specifies whether to work column-wise or row-wise.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>                 If row-wise, then min(n,k) <= m <= n.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of the matrix Q.
  !>                 If column-wise, then min(m,k) <= n <= m.
  !>     @param[in]
  !>     k           rocblas_int. k >= 0.\n
  !>                 The number of columns (if storev is column-wise) or rows (if row-wise) of the
  !>                 original matrix reduced by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD".
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension min(m,k) if column-wise, or min(n,k) if row-wise.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD".
  interface rocsolver_sorgbr
    function rocsolver_sorgbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorgbr_full_rank,&
      rocsolver_sorgbr_rank_0,&
      rocsolver_sorgbr_rank_1
#endif
  end interface
  
  interface rocsolver_dorgbr
    function rocsolver_dorgbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorgbr_full_rank,&
      rocsolver_dorgbr_rank_0,&
      rocsolver_dorgbr_rank_1
#endif
  end interface
  !>     \brief UNGBR generates an m-by-n complex Matrix Q with orthonormal rows or
  !>     columns.
  !> 
  !>     \details
  !>     If storev is column-wise, then the matrix Q has orthonormal columns. If m >= k, Q is defined as the first
  !>     n columns of the product of k Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     If m < k, Q is defined as the product of Householder reflectors of order m
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{m-1}
  !>     \f]
  !> 
  !>     On the other hand, if storev is row-wise, then the matrix Q has orthonormal rows. If n > k, Q is defined as the
  !>     first m rows of the product of k Householder reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     If n <= k, Q is defined as the product of Householder reflectors of order n
  !> 
  !>     \f[
  !>         Q = H_{n-1}H_{n-2}\cdots H_1
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref rocsolver_sgebrd "GEBRD" in its arguments A and tauq or taup.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     storev      rocblas_storev.\n
  !>                 Specifies whether to work column-wise or row-wise.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of the matrix Q.
  !>                 If row-wise, then min(n,k) <= m <= n.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of the matrix Q.
  !>                 If column-wise, then min(m,k) <= n <= m.
  !>     @param[in]
  !>     k           rocblas_int. k >= 0.\n
  !>                 The number of columns (if storev is column-wise) or rows (if row-wise) of the
  !>                 original matrix reduced by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD".
  !>                 On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension min(m,k) if column-wise, or min(n,k) if row-wise.\n
  !>                 The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD".
  interface rocsolver_cungbr
    function rocsolver_cungbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cungbr_full_rank,&
      rocsolver_cungbr_rank_0,&
      rocsolver_cungbr_rank_1
#endif
  end interface
  
  interface rocsolver_zungbr
    function rocsolver_zungbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zungbr_full_rank,&
      rocsolver_zungbr_rank_0,&
      rocsolver_zungbr_rank_1
#endif
  end interface
  !>     \brief ORGTR generates an n-by-n orthogonal Matrix Q.
  !> 
  !>     \details
  !>     Q is defined as the product of n-1 Householder reflectors of order n. If
  !>     uplo indicates upper, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_{n-1}H_{n-2}\cdots H_1
  !>     \f]
  !> 
  !>     On the other hand, if uplo indicates lower, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{n-1}
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by
  !>     \ref rocsolver_ssytrd "SYTRD" in its arguments A and tau.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the \ref rocsolver_ssytrd "SYTRD" factorization was upper or lower
  !>                 triangular. If uplo indicates lower (or upper), then the upper (or lower)
  !>                 part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of rows and columns of the matrix Q.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the Householder vectors as returned
  !>                 by \ref rocsolver_ssytrd "SYTRD". On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension n-1.\n
  !>                 The Householder scalars as returned by \ref rocsolver_ssytrd "SYTRD".
  interface rocsolver_sorgtr
    function rocsolver_sorgtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_sorgtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorgtr_full_rank,&
      rocsolver_sorgtr_rank_0,&
      rocsolver_sorgtr_rank_1
#endif
  end interface
  
  interface rocsolver_dorgtr
    function rocsolver_dorgtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_dorgtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorgtr_full_rank,&
      rocsolver_dorgtr_rank_0,&
      rocsolver_dorgtr_rank_1
#endif
  end interface
  !>     \brief UNGTR generates an n-by-n unitary Matrix Q.
  !> 
  !>     \details
  !>     Q is defined as the product of n-1 Householder reflectors of order n. If
  !>     uplo indicates upper, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_{n-1}H_{n-2}\cdots H_1
  !>     \f]
  !> 
  !>     On the other hand, if uplo indicates lower, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{n-1}
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by
  !>     \ref rocsolver_chetrd "HETRD" in its arguments A and tau.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the \ref rocsolver_chetrd "HETRD" factorization was upper or lower
  !>                 triangular. If uplo indicates lower (or upper), then the upper (or lower)
  !>                 part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of rows and columns of the matrix Q.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the Householder vectors as returned
  !>                 by \ref rocsolver_chetrd "HETRD". On exit, the computed matrix Q.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to type. Array on the GPU of dimension n-1.\n
  !>                 The Householder scalars as returned by \ref rocsolver_chetrd "HETRD".
  interface rocsolver_cungtr
    function rocsolver_cungtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_cungtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cungtr_full_rank,&
      rocsolver_cungtr_rank_0,&
      rocsolver_cungtr_rank_1
#endif
  end interface
  
  interface rocsolver_zungtr
    function rocsolver_zungtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_zungtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zungtr_full_rank,&
      rocsolver_zungtr_rank_0,&
      rocsolver_zungtr_rank_1
#endif
  end interface
  !>     \brief ORM2R multiplies a matrix Q with orthonormal columns by a general m-by-n
  !>     matrix C.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2 \cdots H_k
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the QR factorization \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF"
  !>                         in the first k columns of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, or lda >= n if side is right. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sorm2r
    function rocsolver_sorm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sorm2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorm2r_full_rank,&
      rocsolver_sorm2r_rank_0,&
      rocsolver_sorm2r_rank_1
#endif
  end interface
  
  interface rocsolver_dorm2r
    function rocsolver_dorm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dorm2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorm2r_full_rank,&
      rocsolver_dorm2r_rank_0,&
      rocsolver_dorm2r_rank_1
#endif
  end interface
  !>     \brief UNM2R multiplies a complex matrix Q with orthonormal columns by a
  !>     general m-by-n matrix C.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the QR factorization \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF"
  !>                         in the first k columns of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, or lda >= n if side is right. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  !>
  interface rocsolver_cunm2r
    function rocsolver_cunm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunm2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunm2r_full_rank,&
      rocsolver_cunm2r_rank_0,&
      rocsolver_cunm2r_rank_1
#endif
  end interface
  
  interface rocsolver_zunm2r
    function rocsolver_zunm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunm2r")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunm2r_full_rank,&
      rocsolver_zunm2r_rank_0,&
      rocsolver_zunm2r_rank_1
#endif
  end interface
  !>     \brief ORMQR multiplies a matrix Q with orthonormal columns by a general m-by-n
  !>     matrix C.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the QR factorization \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF"
  !>                         in the first k columns of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, or lda >= n if side is right. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sormqr
    function rocsolver_sormqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sormqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sormqr_full_rank,&
      rocsolver_sormqr_rank_0,&
      rocsolver_sormqr_rank_1
#endif
  end interface
  
  interface rocsolver_dormqr
    function rocsolver_dormqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dormqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dormqr_full_rank,&
      rocsolver_dormqr_rank_0,&
      rocsolver_dormqr_rank_1
#endif
  end interface
  !>     \brief UNMQR multiplies a complex matrix Q with orthonormal columns by a
  !>     general m-by-n matrix C.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the QR factorization \ref rocsolver_sgeqrf "GEQRF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF"
  !>                         in the first k columns of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, or lda >= n if side is right. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunmqr
    function rocsolver_cunmqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunmqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunmqr_full_rank,&
      rocsolver_cunmqr_rank_0,&
      rocsolver_cunmqr_rank_1
#endif
  end interface
  
  interface rocsolver_zunmqr
    function rocsolver_zunmqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunmqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunmqr_full_rank,&
      rocsolver_zunmqr_rank_0,&
      rocsolver_zunmqr_rank_1
#endif
  end interface
  !>     \brief ORML2 multiplies a matrix Q with orthonormal rows by a general m-by-n
  !>     matrix C.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the LQ factorization \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*m if side is left, or lda*n if side is right.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF"
  !>                         in the first k rows of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= k. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  !>
  interface rocsolver_sorml2
    function rocsolver_sorml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sorml2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorml2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorml2_full_rank,&
      rocsolver_sorml2_rank_0,&
      rocsolver_sorml2_rank_1
#endif
  end interface
  
  interface rocsolver_dorml2
    function rocsolver_dorml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dorml2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorml2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorml2_full_rank,&
      rocsolver_dorml2_rank_0,&
      rocsolver_dorml2_rank_1
#endif
  end interface
  !>     \brief UNML2 multiplies a complex matrix Q with orthonormal rows by a general
  !>     m-by-n matrix C.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_k^HH_{k-1}^H\cdots H_1^H
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the LQ factorization \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*m if side is left, or lda*n if side is right.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF"
  !>                         in the first k rows of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= k. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunml2
    function rocsolver_cunml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunml2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunml2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunml2_full_rank,&
      rocsolver_cunml2_rank_0,&
      rocsolver_cunml2_rank_1
#endif
  end interface
  
  interface rocsolver_zunml2
    function rocsolver_zunml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunml2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunml2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunml2_full_rank,&
      rocsolver_zunml2_rank_0,&
      rocsolver_zunml2_rank_1
#endif
  end interface
  !>     \brief ORMLQ multiplies a matrix Q with orthonormal rows by a general m-by-n
  !>     matrix C.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the LQ factorization \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*m if side is left, or lda*n if side is right.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF"
  !>                         in the first k rows of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= k. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sormlq
    function rocsolver_sormlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sormlq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormlq_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sormlq_full_rank,&
      rocsolver_sormlq_rank_0,&
      rocsolver_sormlq_rank_1
#endif
  end interface
  
  interface rocsolver_dormlq
    function rocsolver_dormlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dormlq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormlq_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dormlq_full_rank,&
      rocsolver_dormlq_rank_0,&
      rocsolver_dormlq_rank_1
#endif
  end interface
  !>     \brief UNMLQ multiplies a complex matrix Q with orthonormal rows by a general
  !>     m-by-n matrix C.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_k^HH_{k-1}^H\cdots H_1^H
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is never stored, it is
  !>     calculated from the Householder vectors and scalars returned by the LQ factorization \ref rocsolver_sgelqf "GELQF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*m if side is left, or lda*n if side is right.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF"
  !>                         in the first k rows of its argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= k. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunmlq
    function rocsolver_cunmlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunmlq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunmlq_full_rank,&
      rocsolver_cunmlq_rank_0,&
      rocsolver_cunmlq_rank_1
#endif
  end interface
  
  interface rocsolver_zunmlq
    function rocsolver_zunmlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunmlq")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunmlq_full_rank,&
      rocsolver_zunmlq_rank_0,&
      rocsolver_zunmlq_rank_1
#endif
  end interface
  !>     \brief ORM2L multiplies a matrix Q with orthonormal columns by a general m-by-n
  !>     matrix C.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is
  !>     never stored, it is calculated from the Householder vectors and scalars
  !>     returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be
  !>                         applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the last k columns of its
  !>                         argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, lda >= n if side is right.\n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by
  !>                         \ref rocsolver_sgeqlf "GEQLF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sorm2l
    function rocsolver_sorm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sorm2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sorm2l_full_rank,&
      rocsolver_sorm2l_rank_0,&
      rocsolver_sorm2l_rank_1
#endif
  end interface
  
  interface rocsolver_dorm2l
    function rocsolver_dorm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dorm2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dorm2l_full_rank,&
      rocsolver_dorm2l_rank_0,&
      rocsolver_dorm2l_rank_1
#endif
  end interface
  !>     \brief UNM2L multiplies a complex matrix Q with orthonormal columns by a
  !>     general m-by-n matrix C.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is
  !>     never stored, it is calculated from the Householder vectors and scalars
  !>     returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate
  !>                         transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the last k columns of its
  !>                         argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, lda >= n if side is right.\n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by
  !>                         \ref rocsolver_sgeqlf "GEQLF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunm2l
    function rocsolver_cunm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunm2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunm2l_full_rank,&
      rocsolver_cunm2l_rank_0,&
      rocsolver_cunm2l_rank_1
#endif
  end interface
  
  interface rocsolver_zunm2l
    function rocsolver_zunm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunm2l")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunm2l_full_rank,&
      rocsolver_zunm2l_rank_0,&
      rocsolver_zunm2l_rank_1
#endif
  end interface
  !>     \brief ORMQL multiplies a matrix Q with orthonormal columns by a general m-by-n
  !>     matrix C.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is
  !>     never stored, it is calculated from the Householder vectors and scalars
  !>     returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be
  !>                         applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the last k columns of its
  !>                         argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, lda >= n if side is right.\n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by
  !>                         \ref rocsolver_sgeqlf "GEQLF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sormql
    function rocsolver_sormql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sormql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormql_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sormql_full_rank,&
      rocsolver_sormql_rank_0,&
      rocsolver_sormql_rank_1
#endif
  end interface
  
  interface rocsolver_dormql
    function rocsolver_dormql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dormql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormql_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dormql_full_rank,&
      rocsolver_dormql_rank_0,&
      rocsolver_dormql_rank_1
#endif
  end interface
  !>     \brief UNMQL multiplies a complex matrix Q with orthonormal columns by a
  !>     general m-by-n matrix C.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1
  !>     \f]
  !> 
  !>     of order m if applying from the left, or n if applying from the right. Q is
  !>     never stored, it is calculated from the Householder vectors and scalars
  !>     returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF".
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate
  !>                         transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0; k <= m if side is left, k <= n if side is right.\n
  !>                         The number of Householder reflectors that form Q.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*k.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the last k columns of its
  !>                         argument A.
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= m if side is left, lda >= n if side is right.\n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least k.\n
  !>                         The Householder scalars as returned by
  !>                         \ref rocsolver_sgeqlf "GEQLF".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunmql
    function rocsolver_cunmql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunmql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmql_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunmql_full_rank,&
      rocsolver_cunmql_rank_0,&
      rocsolver_cunmql_rank_1
#endif
  end interface
  
  interface rocsolver_zunmql
    function rocsolver_zunmql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunmql")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmql_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunmql_full_rank,&
      rocsolver_zunmql_rank_0,&
      rocsolver_zunmql_rank_1
#endif
  end interface
  !>     \brief ORMBR multiplies a matrix Q with orthonormal rows or columns by a
  !>     general m-by-n matrix C.
  !> 
  !>     \details
  !>     If storev is column-wise, then the matrix Q has orthonormal columns.
  !>     If storev is row-wise, then the matrix Q has orthonormal rows.
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     The order q of the orthogonal matrix Q is q = m if applying from the left, or q = n if applying from the right.
  !> 
  !>     When storev is column-wise, if q >= k, then Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k,
  !>     \f]
  !> 
  !>     and if q < k, then Q is defined as the product
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{q-1}.
  !>     \f]
  !> 
  !>     When storev is row-wise, if q > k, then Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k,
  !>     \f]
  !> 
  !>     and if q <= k, Q is defined as the product
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{q-1}.
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors and scalars as returned by \ref rocsolver_sgebrd "GEBRD" in its arguments A and tauq or taup.
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     storev              rocblas_storev.\n
  !>                         Specifies whether to work column-wise or row-wise.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0.\n
  !>                         The number of columns (if storev is column-wise) or rows (if row-wise) of the
  !>                         original matrix reduced by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*min(q,k) if column-wise, or lda*q if row-wise.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= q if column-wise, or lda >= min(q,k) if row-wise. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least min(q,k).\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sormbr
    function rocsolver_sormbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sormbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sormbr_full_rank,&
      rocsolver_sormbr_rank_0,&
      rocsolver_sormbr_rank_1
#endif
  end interface
  
  interface rocsolver_dormbr
    function rocsolver_dormbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dormbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dormbr_full_rank,&
      rocsolver_dormbr_rank_0,&
      rocsolver_dormbr_rank_1
#endif
  end interface
  !>     \brief UNMBR multiplies a complex matrix Q with orthonormal rows or columns by
  !>     a general m-by-n matrix C.
  !> 
  !>     \details
  !>     If storev is column-wise, then the matrix Q has orthonormal columns.
  !>     If storev is row-wise, then the matrix Q has orthonormal rows.
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     The order q of the unitary matrix Q is q = m if applying from the left, or q = n if applying from the right.
  !> 
  !>     When storev is column-wise, if q >= k, then Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k,
  !>     \f]
  !> 
  !>     and if q < k, then Q is defined as the product
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{q-1}.
  !>     \f]
  !> 
  !>     When storev is row-wise, if q > k, then Q is defined as the product of k Householder reflectors
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k,
  !>     \f]
  !> 
  !>     and if q <= k, Q is defined as the product
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{q-1}.
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its corresponding
  !>     Householder vectors and scalars as returned by \ref rocsolver_sgebrd "GEBRD" in its arguments A and tauq or taup.
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     storev              rocblas_storev.\n
  !>                         Specifies whether to work column-wise or row-wise.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     k                   rocblas_int. k >= 0.\n
  !>                         The number of columns (if storev is column-wise) or rows (if row-wise) of the
  !>                         original matrix reduced by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*min(q,k) if column-wise, or lda*q if row-wise.\n
  !>                         The Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= q if column-wise, or lda >= min(q,k) if row-wise. \n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least min(q,k).\n
  !>                         The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunmbr
    function rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunmbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunmbr_full_rank,&
      rocsolver_cunmbr_rank_0,&
      rocsolver_cunmbr_rank_1
#endif
  end interface
  
  interface rocsolver_zunmbr
    function rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunmbr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_column_wise)),value :: storev
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: k
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunmbr_full_rank,&
      rocsolver_zunmbr_rank_0,&
      rocsolver_zunmbr_rank_1
#endif
  end interface
  !>     \brief ORMTR multiplies an orthogonal matrix Q by a general m-by-n matrix C.
  !> 
  !>     \details
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^TC & \: \text{Transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^T & \: \text{Transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     The order q of the orthogonal matrix Q is q = m if applying from the left, or
  !>     q = n if applying from the right.
  !> 
  !>     Q is defined as a product of q-1 Householder reflectors. If
  !>     uplo indicates upper, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_{q-1}H_{q-2}\cdots H_1.
  !>     \f]
  !> 
  !>     On the other hand, if uplo indicates lower, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{q-1}
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors and scalars as returned by
  !>     \ref rocsolver_ssytrd "SYTRD" in its arguments A and tau.
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     uplo                rocblas_fill.\n
  !>                         Specifies whether the \ref rocsolver_ssytrd "SYTRD" factorization was upper or
  !>                         lower triangular. If uplo indicates lower (or upper), then the upper (or
  !>                         lower) part of A is not used.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its transpose is to be
  !>                         applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*q.\n
  !>                         On entry, the Householder vectors as
  !>                         returned by \ref rocsolver_ssytrd "SYTRD".
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= q.\n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least q-1.\n
  !>                         The Householder scalars as returned by
  !>                         \ref rocsolver_ssytrd "SYTRD".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_sormtr
    function rocsolver_sormtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_sormtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sormtr_full_rank,&
      rocsolver_sormtr_rank_0,&
      rocsolver_sormtr_rank_1
#endif
  end interface
  
  interface rocsolver_dormtr
    function rocsolver_dormtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_dormtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dormtr_full_rank,&
      rocsolver_dormtr_rank_0,&
      rocsolver_dormtr_rank_1
#endif
  end interface
  !>     \brief UNMTR multiplies a unitary matrix Q by a general m-by-n matrix C.
  !> 
  !>     \details
  !>     The matrix Q is applied in one of the following forms, depending on
  !>     the values of side and trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         QC & \: \text{No transpose from the left,}\newline
  !>
  !>         Q^HC & \: \text{Conjugate transpose from the left,}\newline
  !>
  !>         CQ & \: \text{No transpose from the right, and}\newline
  !>
  !>         CQ^H & \: \text{Conjugate transpose from the right.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     The order q of the unitary matrix Q is q = m if applying from the left, or
  !>     q = n if applying from the right.
  !> 
  !>     Q is defined as a product of q-1 Householder reflectors. If
  !>     uplo indicates upper, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_{q-1}H_{q-2}\cdots H_1.
  !>     \f]
  !> 
  !>     On the other hand, if uplo indicates lower, then Q has the form
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_{q-1}
  !>     \f]
  !> 
  !>     The Householder matrices \f$H_i\f$ are never stored, they are computed from its
  !>     corresponding Householder vectors and scalars as returned by
  !>     \ref rocsolver_chetrd "HETRD" in its arguments A and tau.
  !> 
  !>     @param[in]
  !>     handle              rocblas_handle.
  !>     @param[in]
  !>     side                rocblas_side.\n
  !>                         Specifies from which side to apply Q.
  !>     @param[in]
  !>     uplo                rocblas_fill.\n
  !>                         Specifies whether the \ref rocsolver_chetrd "HETRD" factorization was upper or
  !>                         lower triangular. If uplo indicates lower (or upper), then the upper (or
  !>                         lower) part of A is not used.
  !>     @param[in]
  !>     trans               rocblas_operation.\n
  !>                         Specifies whether the matrix Q or its conjugate
  !>                         transpose is to be applied.
  !>     @param[in]
  !>     m                   rocblas_int. m >= 0.\n
  !>                         Number of rows of matrix C.
  !>     @param[in]
  !>     n                   rocblas_int. n >= 0.\n
  !>                         Number of columns of matrix C.
  !>     @param[in]
  !>     A                   pointer to type. Array on the GPU of size lda*q.\n
  !>                         On entry, the Householder vectors as
  !>                         returned by \ref rocsolver_chetrd "HETRD".
  !>     @param[in]
  !>     lda                 rocblas_int. lda >= q.\n
  !>                         Leading dimension of A.
  !>     @param[in]
  !>     ipiv                pointer to type. Array on the GPU of dimension at least q-1.\n
  !>                         The Householder scalars as returned by
  !>                         \ref rocsolver_chetrd "HETRD".
  !>     @param[inout]
  !>     C                   pointer to type. Array on the GPU of size ldc*n.\n
  !>                         On entry, the matrix C. On exit, it is overwritten with
  !>                         Q*C, C*Q, Q'*C, or C*Q'.
  !>     @param[in]
  !>     ldc                 rocblas_int. ldc >= m.\n
  !>                         Leading dimension of C.
  interface rocsolver_cunmtr
    function rocsolver_cunmtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_cunmtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cunmtr_full_rank,&
      rocsolver_cunmtr_rank_0,&
      rocsolver_cunmtr_rank_1
#endif
  end interface
  
  interface rocsolver_zunmtr
    function rocsolver_zunmtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) bind(c, name="rocsolver_zunmtr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_side_left)),value :: side
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zunmtr_full_rank,&
      rocsolver_zunmtr_rank_0,&
      rocsolver_zunmtr_rank_1
#endif
  end interface
  !>     \brief BDSQR computes the singular value decomposition (SVD) of an
  !>     n-by-n bidiagonal matrix B, using the implicit QR algorithm.
  !> 
  !>     \details
  !>     The SVD of B has the form:
  !> 
  !>     \f[
  !>         B = QSP'
  !>     \f]
  !> 
  !>     where S is the n-by-n diagonal matrix of singular values of B, the columns of Q are the left
  !>     singular vectors of B, and the columns of P are its right singular vectors.
  !> 
  !>     The computation of the singular vectors is optional; this function accepts input matrices
  !>     U (of size nu-by-n) and V (of size n-by-nv) that are overwritten with \f$UQ\f$ and \f$P'V\f$. If nu = 0
  !>     no left vectors are computed; if nv = 0 no right vectors are computed.
  !> 
  !>     Optionally, this function can also compute \f$Q'C\f$ for a given n-by-nc input matrix C.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether B is upper or lower bidiagonal.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of rows and columns of matrix B.
  !>     @param[in]
  !>     nv          rocblas_int. nv >= 0.\n
  !>                 The number of columns of matrix V.
  !>     @param[in]
  !>     nu          rocblas_int. nu >= 0.\n
  !>                 The number of rows of matrix U.
  !>     @param[in]
  !>     nc          rocblas_int. nu >= 0.\n
  !>                 The number of columns of matrix C.
  !>     @param[inout]
  !>     D           pointer to real type. Array on the GPU of dimension n.\n
  !>                 On entry, the diagonal elements of B. On exit, if info = 0,
  !>                 the singular values of B in decreasing order; if info > 0,
  !>                 the diagonal elements of a bidiagonal matrix
  !>                 orthogonally equivalent to B.
  !>     @param[inout]
  !>     E           pointer to real type. Array on the GPU of dimension n-1.\n
  !>                 On entry, the off-diagonal elements of B. On exit, if info > 0,
  !>                 the off-diagonal elements of a bidiagonal matrix
  !>                 orthogonally equivalent to B (if info = 0 this matrix converges to zero).
  !>     @param[inout]
  !>     V           pointer to type. Array on the GPU of dimension ldv*nv.\n
  !>                 On entry, the matrix V. On exit, it is overwritten with P'*V.
  !>                 (Not referenced if nv = 0).
  !>     @param[in]
  !>     ldv         rocblas_int. ldv >= n if nv > 0, or ldv >=1 if nv = 0.\n
  !>                 The leading dimension of V.
  !>     @param[inout]
  !>     U           pointer to type. Array on the GPU of dimension ldu*n.\n
  !>                 On entry, the matrix U. On exit, it is overwritten with U*Q.
  !>                 (Not referenced if nu = 0).
  !>     @param[in]
  !>     ldu         rocblas_int. ldu >= nu.\n
  !>                 The leading dimension of U.
  !>     @param[inout]
  !>     C           pointer to type. Array on the GPU of dimension ldc*nc.\n
  !>                 On entry, the matrix C. On exit, it is overwritten with Q'*C.
  !>                 (Not referenced if nc = 0).
  !>     @param[in]
  !>     ldc         rocblas_int. ldc >= n if nc > 0, or ldc >=1 if nc = 0.\n
  !>                 The leading dimension of C.
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit.
  !>                 If info = i > 0, i elements of E have not converged to zero.
  interface rocsolver_sbdsqr
    function rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) bind(c, name="rocsolver_sbdsqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nv
      integer(c_int),value :: nu
      integer(c_int),value :: nc
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sbdsqr_full_rank,&
      rocsolver_sbdsqr_rank_0,&
      rocsolver_sbdsqr_rank_1
#endif
  end interface
  
  interface rocsolver_dbdsqr
    function rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) bind(c, name="rocsolver_dbdsqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nv
      integer(c_int),value :: nu
      integer(c_int),value :: nc
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dbdsqr_full_rank,&
      rocsolver_dbdsqr_rank_0,&
      rocsolver_dbdsqr_rank_1
#endif
  end interface
  
  interface rocsolver_cbdsqr
    function rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) bind(c, name="rocsolver_cbdsqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nv
      integer(c_int),value :: nu
      integer(c_int),value :: nc
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cbdsqr_full_rank,&
      rocsolver_cbdsqr_rank_0,&
      rocsolver_cbdsqr_rank_1
#endif
  end interface
  
  interface rocsolver_zbdsqr
    function rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) bind(c, name="rocsolver_zbdsqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nv
      integer(c_int),value :: nu
      integer(c_int),value :: nc
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zbdsqr_full_rank,&
      rocsolver_zbdsqr_rank_0,&
      rocsolver_zbdsqr_rank_1
#endif
  end interface
  !>     \brief STERF computes the eigenvalues of a symmetric tridiagonal matrix.
  !> 
  !>     \details
  !>     The eigenvalues of the symmetric tridiagonal matrix are computed by the
  !>     Pal-Walker-Kahan variant of the QL/QR algorithm, and returned in
  !>     increasing order.
  !> 
  !>     The matrix is not represented explicitly, but rather as the array of
  !>     diagonal elements D and the array of symmetric off-diagonal elements E.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the tridiagonal matrix.
  !>     @param[inout]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               On entry, the diagonal elements of the tridiagonal matrix.
  !>               On exit, if info = 0, the eigenvalues in increasing order.
  !>               If info > 0, the diagonal elements of a tridiagonal matrix
  !>               that is similar to the original matrix (i.e. has the same
  !>               eigenvalues).
  !>     @param[inout]
  !>     E         pointer to real type. Array on the GPU of dimension n-1.\n
  !>               On entry, the off-diagonal elements of the tridiagonal matrix.
  !>               On exit, if info = 0, this array converges to zero.
  !>               If info > 0, the off-diagonal elements of a tridiagonal matrix
  !>               that is similar to the original matrix (i.e. has the same
  !>               eigenvalues).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, STERF did not converge. i elements of E did not
  !>               converge to zero.
  !>
  interface rocsolver_ssterf
    function rocsolver_ssterf_(handle,n,D,E,myInfo) bind(c, name="rocsolver_ssterf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssterf_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssterf_rank_0,&
      rocsolver_ssterf_rank_1
#endif
  end interface
  
  interface rocsolver_dsterf
    function rocsolver_dsterf_(handle,n,D,E,myInfo) bind(c, name="rocsolver_dsterf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsterf_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsterf_rank_0,&
      rocsolver_dsterf_rank_1
#endif
  end interface
  !>     \brief STEQR computes the eigenvalues and (optionally) eigenvectors of
  !>     a symmetric tridiagonal matrix.
  !> 
  !>     \details
  !>     The eigenvalues of the symmetric tridiagonal matrix are computed by the
  !>     implicit QL/QR algorithm, and returned in increasing order.
  !> 
  !>     The matrix is not represented explicitly, but rather as the array of
  !>     diagonal elements D and the array of symmetric off-diagonal elements E.
  !>     When D and E correspond to the tridiagonal form of a full symmetric/Hermitian matrix, as returned by, e.g.,
  !>     \ref rocsolver_ssytrd "SYTRD" or \ref rocsolver_chetrd "HETRD", the eigenvectors of the original matrix can also
  !>     be computed, depending on the value of evect.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies how the eigenvectors are computed.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the tridiagonal matrix.
  !>     @param[inout]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               On entry, the diagonal elements of the tridiagonal matrix.
  !>               On exit, if info = 0, the eigenvalues in increasing order.
  !>               If info > 0, the diagonal elements of a tridiagonal matrix
  !>               that is similar to the original matrix (i.e. has the same
  !>               eigenvalues).
  !>     @param[inout]
  !>     E         pointer to real type. Array on the GPU of dimension n-1.\n
  !>               On entry, the off-diagonal elements of the tridiagonal matrix.
  !>               On exit, if info = 0, this array converges to zero.
  !>               If info > 0, the off-diagonal elements of a tridiagonal matrix
  !>               that is similar to the original matrix (i.e. has the same
  !>               eigenvalues).
  !>     @param[inout]
  !>     C         pointer to type. Array on the GPU of dimension ldc*n.\n
  !>               On entry, if evect is original, the orthogonal/unitary matrix
  !>               used for the reduction to tridiagonal form as returned by, e.g.,
  !>               \ref rocsolver_sorgtr "ORGTR" or \ref rocsolver_cungtr "UNGTR".
  !>               On exit, it is overwritten with the eigenvectors of the original
  !>               symmetric/Hermitian matrix (if evect is original), or the
  !>               eigenvectors of the tridiagonal matrix (if evect is tridiagonal).
  !>               (Not referenced if evect is none).
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n if evect is original or tridiagonal.\n
  !>               Specifies the leading dimension of C.
  !>               (Not referenced if evect is none).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, STEQR did not converge. i elements of E did not
  !>               converge to zero.
  !>
  interface rocsolver_ssteqr
    function rocsolver_ssteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_ssteqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssteqr_full_rank,&
      rocsolver_ssteqr_rank_0,&
      rocsolver_ssteqr_rank_1
#endif
  end interface
  
  interface rocsolver_dsteqr
    function rocsolver_dsteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_dsteqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsteqr_full_rank,&
      rocsolver_dsteqr_rank_0,&
      rocsolver_dsteqr_rank_1
#endif
  end interface
  
  interface rocsolver_csteqr
    function rocsolver_csteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_csteqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csteqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csteqr_full_rank,&
      rocsolver_csteqr_rank_0,&
      rocsolver_csteqr_rank_1
#endif
  end interface
  
  interface rocsolver_zsteqr
    function rocsolver_zsteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_zsteqr")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsteqr_full_rank,&
      rocsolver_zsteqr_rank_0,&
      rocsolver_zsteqr_rank_1
#endif
  end interface
  !>     \brief STEDC computes the eigenvalues and (optionally) eigenvectors of
  !>     a symmetric tridiagonal matrix.
  !> 
  !>     \details
  !>     This function uses the divide and conquer method to compute the eigenvectors.
  !>     The eigenvalues are returned in increasing order.
  !> 
  !>     The matrix is not represented explicitly, but rather as the array of
  !>     diagonal elements D and the array of symmetric off-diagonal elements E.
  !>     When D and E correspond to the tridiagonal form of a full symmetric/Hermitian matrix, as returned by, e.g.,
  !>     \ref rocsolver_ssytrd "SYTRD" or \ref rocsolver_chetrd "HETRD", the eigenvectors of the original matrix can also
  !>     be computed, depending on the value of evect.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies how the eigenvectors are computed.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the tridiagonal matrix.
  !>     @param[inout]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               On entry, the diagonal elements of the tridiagonal matrix.
  !>               On exit, if info = 0, the eigenvalues in increasing order.
  !>     @param[inout]
  !>     E         pointer to real type. Array on the GPU of dimension n-1.\n
  !>               On entry, the off-diagonal elements of the tridiagonal matrix.
  !>               On exit, if info = 0, the values of this array are destroyed.
  !>     @param[inout]
  !>     C         pointer to type. Array on the GPU of dimension ldc*n.\n
  !>               On entry, if evect is original, the orthogonal/unitary matrix
  !>               used for the reduction to tridiagonal form as returned by, e.g.,
  !>               \ref rocsolver_sorgtr "ORGTR" or \ref rocsolver_cungtr "UNGTR".
  !>               On exit, if info = 0, it is overwritten with the eigenvectors of the original
  !>               symmetric/Hermitian matrix (if evect is original), or the
  !>               eigenvectors of the tridiagonal matrix (if evect is tridiagonal).
  !>               (Not referenced if evect is none).
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n if evect is original or tridiagonal.\n
  !>               Specifies the leading dimension of C. (Not referenced if evect is none).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, STEDC failed to compute an eigenvalue on the sub-matrix formed by
  !>               the rows and columns info/(n+1) through mod(info,n+1).
  interface rocsolver_sstedc
    function rocsolver_sstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_sstedc")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sstedc_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sstedc_full_rank,&
      rocsolver_sstedc_rank_0,&
      rocsolver_sstedc_rank_1
#endif
  end interface
  
  interface rocsolver_dstedc
    function rocsolver_dstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_dstedc")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dstedc_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dstedc_full_rank,&
      rocsolver_dstedc_rank_0,&
      rocsolver_dstedc_rank_1
#endif
  end interface
  
  interface rocsolver_cstedc
    function rocsolver_cstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_cstedc")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cstedc_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cstedc_full_rank,&
      rocsolver_cstedc_rank_0,&
      rocsolver_cstedc_rank_1
#endif
  end interface
  
  interface rocsolver_zstedc
    function rocsolver_zstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_zstedc")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zstedc_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(c_int),value :: n
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zstedc_full_rank,&
      rocsolver_zstedc_rank_0,&
      rocsolver_zstedc_rank_1
#endif
  end interface
  !>     \brief GETF2_NPVT computes the LU factorization of a general m-by-n matrix A
  !>     without partial pivoting.
  !> 
  !>     \details
  !>     (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with small and mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = LU
  !>     \f]
  !> 
  !>     where L is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and U is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     Note: Although this routine can offer better performance, Gaussian elimination without pivoting is not backward stable.
  !>     If numerical accuracy is compromised, use the legacy-LAPACK-like API \ref rocsolver_sgetf2 "GETF2" routines instead.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix A to be factored.
  !>               On exit, the factors L and U from the factorization.
  !>               The unit diagonal elements of L are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j > 0, U is singular. U[j,j] is the first zero element in the diagonal. The factorization from
  !>               this point might be incomplete.
  interface rocsolver_sgetf2_npvt
    function rocsolver_sgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_sgetf2_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetf2_npvt_full_rank,&
      rocsolver_sgetf2_npvt_rank_0,&
      rocsolver_sgetf2_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_dgetf2_npvt
    function rocsolver_dgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_dgetf2_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetf2_npvt_full_rank,&
      rocsolver_dgetf2_npvt_rank_0,&
      rocsolver_dgetf2_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_cgetf2_npvt
    function rocsolver_cgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_cgetf2_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetf2_npvt_full_rank,&
      rocsolver_cgetf2_npvt_rank_0,&
      rocsolver_cgetf2_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_zgetf2_npvt
    function rocsolver_zgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_zgetf2_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetf2_npvt_full_rank,&
      rocsolver_zgetf2_npvt_rank_0,&
      rocsolver_zgetf2_npvt_rank_1
#endif
  end interface
  !>     \brief GETF2_NPVT_BATCHED computes the LU factorization of a batch of
  !>     general m-by-n matrices without partial pivoting.
  !> 
  !>     \details
  !>     (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with small and mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = L_iU_i
  !>     \f]
  !> 
  !>     where \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     Note: Although this routine can offer better performance, Gaussian elimination without pivoting is not backward stable.
  !>     If numerical accuracy is compromised, use the legacy-LAPACK-like API \ref rocsolver_sgetf2_batched "GETF2_BATCHED" routines instead.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorizations.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero element in the diagonal. The factorization from
  !>               this point might be incomplete.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_sgetf2_npvt_batched
    function rocsolver_sgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_sgetf2_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetf2_npvt_batched_full_rank,&
      rocsolver_sgetf2_npvt_batched_rank_0,&
      rocsolver_sgetf2_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetf2_npvt_batched
    function rocsolver_dgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dgetf2_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetf2_npvt_batched_full_rank,&
      rocsolver_dgetf2_npvt_batched_rank_0,&
      rocsolver_dgetf2_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetf2_npvt_batched
    function rocsolver_cgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_cgetf2_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetf2_npvt_batched_full_rank,&
      rocsolver_cgetf2_npvt_batched_rank_0,&
      rocsolver_cgetf2_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetf2_npvt_batched
    function rocsolver_zgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_zgetf2_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetf2_npvt_batched_full_rank,&
      rocsolver_zgetf2_npvt_batched_rank_0,&
      rocsolver_zgetf2_npvt_batched_rank_1
#endif
  end interface
  !>     \brief GETF2_NPVT_STRIDED_BATCHED computes the LU factorization of a batch
  !>     of general m-by-n matrices without partial pivoting.
  !> 
  !>     \details
  !>     (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with small and mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = L_iU_i
  !>     \f]
  !> 
  !>     where \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     Note: Although this routine can offer better performance, Gaussian elimination without pivoting is not backward stable.
  !>     If numerical accuracy is compromised, use the legacy-LAPACK-like API \ref rocsolver_sgetf2_strided_batched "GETF2_STRIDED_BATCHED" routines instead.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorization.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero element in the diagonal. The factorization from
  !>               this point might be incomplete.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_sgetf2_npvt_strided_batched
    function rocsolver_sgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_sgetf2_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetf2_npvt_strided_batched_full_rank,&
      rocsolver_sgetf2_npvt_strided_batched_rank_0,&
      rocsolver_sgetf2_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetf2_npvt_strided_batched
    function rocsolver_dgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dgetf2_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetf2_npvt_strided_batched_full_rank,&
      rocsolver_dgetf2_npvt_strided_batched_rank_0,&
      rocsolver_dgetf2_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetf2_npvt_strided_batched
    function rocsolver_cgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_cgetf2_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetf2_npvt_strided_batched_full_rank,&
      rocsolver_cgetf2_npvt_strided_batched_rank_0,&
      rocsolver_cgetf2_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetf2_npvt_strided_batched
    function rocsolver_zgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_zgetf2_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetf2_npvt_strided_batched_full_rank,&
      rocsolver_zgetf2_npvt_strided_batched_rank_0,&
      rocsolver_zgetf2_npvt_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRF_NPVT computes the LU factorization of a general m-by-n matrix A
  !>     without partial pivoting.
  !> 
  !>     \details
  !>     (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = LU
  !>     \f]
  !> 
  !>     where L is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and U is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     Note: Although this routine can offer better performance, Gaussian elimination without pivoting is not backward stable.
  !>     If numerical accuracy is compromised, use the legacy-LAPACK-like API \ref rocsolver_sgetrf "GETRF" routines instead.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix A to be factored.
  !>               On exit, the factors L and U from the factorization.
  !>               The unit diagonal elements of L are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j > 0, U is singular. U[j,j] is the first zero element in the diagonal. The factorization from
  !>               this point might be incomplete.
  interface rocsolver_sgetrf_npvt
    function rocsolver_sgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_sgetrf_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrf_npvt_full_rank,&
      rocsolver_sgetrf_npvt_rank_0,&
      rocsolver_sgetrf_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrf_npvt
    function rocsolver_dgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_dgetrf_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrf_npvt_full_rank,&
      rocsolver_dgetrf_npvt_rank_0,&
      rocsolver_dgetrf_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrf_npvt
    function rocsolver_cgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_cgetrf_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrf_npvt_full_rank,&
      rocsolver_cgetrf_npvt_rank_0,&
      rocsolver_cgetrf_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrf_npvt
    function rocsolver_zgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_zgetrf_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrf_npvt_full_rank,&
      rocsolver_zgetrf_npvt_rank_0,&
      rocsolver_zgetrf_npvt_rank_1
#endif
  end interface
  !>     \brief GETRF_NPVT_BATCHED computes the LU factorization of a batch of
  !>     general m-by-n matrices without partial pivoting.
  !> 
  !>     \details
  !>     (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = L_iU_i
  !>     \f]
  !> 
  !>     where \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     Note: Although this routine can offer better performance, Gaussian elimination without pivoting is not backward stable.
  !>     If numerical accuracy is compromised, use the legacy-LAPACK-like API \ref rocsolver_sgetrf_batched "GETRF_BATCHED" routines instead.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorizations.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero element in the diagonal. The factorization from
  !>               this point might be incomplete.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetrf_npvt_batched
    function rocsolver_sgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_sgetrf_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrf_npvt_batched_full_rank,&
      rocsolver_sgetrf_npvt_batched_rank_0,&
      rocsolver_sgetrf_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrf_npvt_batched
    function rocsolver_dgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dgetrf_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrf_npvt_batched_full_rank,&
      rocsolver_dgetrf_npvt_batched_rank_0,&
      rocsolver_dgetrf_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrf_npvt_batched
    function rocsolver_cgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_cgetrf_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrf_npvt_batched_full_rank,&
      rocsolver_cgetrf_npvt_batched_rank_0,&
      rocsolver_cgetrf_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrf_npvt_batched
    function rocsolver_zgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_zgetrf_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrf_npvt_batched_full_rank,&
      rocsolver_zgetrf_npvt_batched_rank_0,&
      rocsolver_zgetrf_npvt_batched_rank_1
#endif
  end interface
  !>     \brief GETRF_NPVT_STRIDED_BATCHED computes the LU factorization of a batch
  !>     of general m-by-n matrices without partial pivoting.
  !> 
  !>     \details
  !>     (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = L_iU_i
  !>     \f]
  !> 
  !>     where \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     Note: Although this routine can offer better performance, Gaussian elimination without pivoting is not backward stable.
  !>     If numerical accuracy is compromised, use the legacy-LAPACK-like API \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED" routines instead.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorization.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero element in the diagonal. The factorization from
  !>               this point might be incomplete.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetrf_npvt_strided_batched
    function rocsolver_sgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_sgetrf_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrf_npvt_strided_batched_full_rank,&
      rocsolver_sgetrf_npvt_strided_batched_rank_0,&
      rocsolver_sgetrf_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrf_npvt_strided_batched
    function rocsolver_dgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dgetrf_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrf_npvt_strided_batched_full_rank,&
      rocsolver_dgetrf_npvt_strided_batched_rank_0,&
      rocsolver_dgetrf_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrf_npvt_strided_batched
    function rocsolver_cgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_cgetrf_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrf_npvt_strided_batched_full_rank,&
      rocsolver_cgetrf_npvt_strided_batched_rank_0,&
      rocsolver_cgetrf_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrf_npvt_strided_batched
    function rocsolver_zgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_zgetrf_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrf_npvt_strided_batched_full_rank,&
      rocsolver_zgetrf_npvt_strided_batched_rank_0,&
      rocsolver_zgetrf_npvt_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETF2 computes the LU factorization of a general m-by-n matrix A
  !>     using partial pivoting with row interchanges.
  !> 
  !>     \details
  !>     (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with small and mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = PLU
  !>     \f]
  !> 
  !>     where P is a permutation matrix, L is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and U is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix A to be factored.
  !>               On exit, the factors L and U from the factorization.
  !>               The unit diagonal elements of L are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension min(m,n).\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= i <= min(m,n), the row i of the
  !>               matrix was interchanged with row ipiv[i].
  !>               Matrix P of the factorization can be derived from ipiv.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j > 0, U is singular. U[j,j] is the first zero pivot.
  interface rocsolver_sgetf2
    function rocsolver_sgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetf2_full_rank,&
      rocsolver_sgetf2_rank_0,&
      rocsolver_sgetf2_rank_1
#endif
  end interface
  
  interface rocsolver_dgetf2
    function rocsolver_dgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetf2_full_rank,&
      rocsolver_dgetf2_rank_0,&
      rocsolver_dgetf2_rank_1
#endif
  end interface
  
  interface rocsolver_cgetf2
    function rocsolver_cgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetf2_full_rank,&
      rocsolver_cgetf2_rank_0,&
      rocsolver_cgetf2_rank_1
#endif
  end interface
  
  interface rocsolver_zgetf2
    function rocsolver_zgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetf2_full_rank,&
      rocsolver_zgetf2_rank_0,&
      rocsolver_zgetf2_rank_1
#endif
  end interface
  !>     \brief GETF2_BATCHED computes the LU factorization of a batch of general
  !>     m-by-n matrices using partial pivoting with row interchanges.
  !> 
  !>     \details
  !>     (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with small and mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = P_iL_iU_i
  !>     \f]
  !> 
  !>     where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorizations.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors of pivot indices ipiv_i (corresponding to A_i).
  !>               Dimension of ipiv_i is min(m,n).
  !>               Elements of ipiv_i are 1-based indices.
  !>               For each instance A_i in the batch and for 1 <= j <= min(m,n), the row j of the
  !>               matrix A_i was interchanged with row ipiv_i[j].
  !>               Matrix P_i of the factorization can be derived from ipiv_i.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= min(m,n).
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_sgetf2_batched
    function rocsolver_sgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_sgetf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetf2_batched_full_rank,&
      rocsolver_sgetf2_batched_rank_0,&
      rocsolver_sgetf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetf2_batched
    function rocsolver_dgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dgetf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetf2_batched_full_rank,&
      rocsolver_dgetf2_batched_rank_0,&
      rocsolver_dgetf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetf2_batched
    function rocsolver_cgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_cgetf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetf2_batched_full_rank,&
      rocsolver_cgetf2_batched_rank_0,&
      rocsolver_cgetf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetf2_batched
    function rocsolver_zgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zgetf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetf2_batched_full_rank,&
      rocsolver_zgetf2_batched_rank_0,&
      rocsolver_zgetf2_batched_rank_1
#endif
  end interface
  !>     \brief GETF2_STRIDED_BATCHED computes the LU factorization of a batch of
  !>     general m-by-n matrices using partial pivoting with row interchanges.
  !> 
  !>     \details
  !>     (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with small and mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = P_iL_iU_i
  !>     \f]
  !> 
  !>     where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorization.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors of pivots indices ipiv_i (corresponding to A_i).
  !>               Dimension of ipiv_i is min(m,n).
  !>               Elements of ipiv_i are 1-based indices.
  !>               For each instance A_i in the batch and for 1 <= j <= min(m,n), the row j of the
  !>               matrix A_i was interchanged with row ipiv_i[j].
  !>               Matrix P_i of the factorization can be derived from ipiv_i.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= min(m,n).
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_sgetf2_strided_batched
    function rocsolver_sgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_sgetf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetf2_strided_batched_full_rank,&
      rocsolver_sgetf2_strided_batched_rank_0,&
      rocsolver_sgetf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetf2_strided_batched
    function rocsolver_dgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dgetf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetf2_strided_batched_full_rank,&
      rocsolver_dgetf2_strided_batched_rank_0,&
      rocsolver_dgetf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetf2_strided_batched
    function rocsolver_cgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_cgetf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetf2_strided_batched_full_rank,&
      rocsolver_cgetf2_strided_batched_rank_0,&
      rocsolver_cgetf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetf2_strided_batched
    function rocsolver_zgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zgetf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetf2_strided_batched_full_rank,&
      rocsolver_zgetf2_strided_batched_rank_0,&
      rocsolver_zgetf2_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRF computes the LU factorization of a general m-by-n matrix A
  !>     using partial pivoting with row interchanges.
  !> 
  !>     \details
  !>     (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = PLU
  !>     \f]
  !> 
  !>     where P is a permutation matrix, L is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and U is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix A to be factored.
  !>               On exit, the factors L and U from the factorization.
  !>               The unit diagonal elements of L are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension min(m,n).\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= i <= min(m,n), the row i of the
  !>               matrix was interchanged with row ipiv[i].
  !>               Matrix P of the factorization can be derived from ipiv.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j > 0, U is singular. U[j,j] is the first zero pivot.
  interface rocsolver_sgetrf
    function rocsolver_sgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrf_full_rank,&
      rocsolver_sgetrf_rank_0,&
      rocsolver_sgetrf_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrf
    function rocsolver_dgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrf_full_rank,&
      rocsolver_dgetrf_rank_0,&
      rocsolver_dgetrf_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrf
    function rocsolver_cgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrf_full_rank,&
      rocsolver_cgetrf_rank_0,&
      rocsolver_cgetrf_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrf
    function rocsolver_zgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrf_full_rank,&
      rocsolver_zgetrf_rank_0,&
      rocsolver_zgetrf_rank_1
#endif
  end interface
  !>     \brief GETRF_BATCHED computes the LU factorization of a batch of general
  !>     m-by-n matrices using partial pivoting with row interchanges.
  !> 
  !>     \details
  !>     (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = P_iL_iU_i
  !>     \f]
  !> 
  !>     where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorizations.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors of pivot indices ipiv_i (corresponding to A_i).
  !>               Dimension of ipiv_i is min(m,n).
  !>               Elements of ipiv_i are 1-based indices.
  !>               For each instance A_i in the batch and for 1 <= j <= min(m,n), the row j of the
  !>               matrix A_i was interchanged with row ipiv_i[j].
  !>               Matrix P_i of the factorization can be derived from ipiv_i.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= min(m,n).
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_sgetrf_batched
    function rocsolver_sgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_sgetrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrf_batched_full_rank,&
      rocsolver_sgetrf_batched_rank_0,&
      rocsolver_sgetrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrf_batched
    function rocsolver_dgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dgetrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrf_batched_full_rank,&
      rocsolver_dgetrf_batched_rank_0,&
      rocsolver_dgetrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrf_batched
    function rocsolver_cgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_cgetrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrf_batched_full_rank,&
      rocsolver_cgetrf_batched_rank_0,&
      rocsolver_cgetrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrf_batched
    function rocsolver_zgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zgetrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrf_batched_full_rank,&
      rocsolver_zgetrf_batched_rank_0,&
      rocsolver_zgetrf_batched_rank_1
#endif
  end interface
  !>     \brief GETRF_STRIDED_BATCHED computes the LU factorization of a batch of
  !>     general m-by-n matrices using partial pivoting with row interchanges.
  !> 
  !>     \details
  !>     (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without rocBLAS calls
  !>     could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the
  !>     "Tuning rocSOLVER performance" section of the Library Design Guide).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_i = P_iL_iU_i
  !>     \f]
  !> 
  !>     where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit
  !>     diagonal elements (lower trapezoidal if m > n), and \f$U_i\f$ is upper
  !>     triangular (upper trapezoidal if m < n).
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_i to be factored.
  !>               On exit, the factors L_i and U_i from the factorization.
  !>               The unit diagonal elements of L_i are not stored.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors of pivots indices ipiv_i (corresponding to A_i).
  !>               Dimension of ipiv_i is min(m,n).
  !>               Elements of ipiv_i are 1-based indices.
  !>               For each instance A_i in the batch and for 1 <= j <= min(m,n), the row j of the
  !>               matrix A_i was interchanged with row ipiv_i[j].
  !>               Matrix P_i of the factorization can be derived from ipiv_i.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= min(m,n).
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_sgetrf_strided_batched
    function rocsolver_sgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_sgetrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrf_strided_batched_full_rank,&
      rocsolver_sgetrf_strided_batched_rank_0,&
      rocsolver_sgetrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrf_strided_batched
    function rocsolver_dgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dgetrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrf_strided_batched_full_rank,&
      rocsolver_dgetrf_strided_batched_rank_0,&
      rocsolver_dgetrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrf_strided_batched
    function rocsolver_cgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_cgetrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrf_strided_batched_full_rank,&
      rocsolver_cgetrf_strided_batched_rank_0,&
      rocsolver_cgetrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrf_strided_batched
    function rocsolver_zgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zgetrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrf_strided_batched_full_rank,&
      rocsolver_zgetrf_strided_batched_rank_0,&
      rocsolver_zgetrf_strided_batched_rank_1
#endif
  end interface
  !>     \brief GEQR2 computes a QR factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = Q\left[\begin{array}{c}
  !>         R\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where R is upper triangular (upper trapezoidal if m < n), and Q is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i v_i'
  !>     \f]
  !> 
  !>     where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and above the diagonal contain the
  !>               factor R; the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgeqr2
    function rocsolver_sgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqr2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqr2_full_rank,&
      rocsolver_sgeqr2_rank_0,&
      rocsolver_sgeqr2_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqr2
    function rocsolver_dgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqr2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqr2_full_rank,&
      rocsolver_dgeqr2_rank_0,&
      rocsolver_dgeqr2_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqr2
    function rocsolver_cgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqr2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqr2_full_rank,&
      rocsolver_cgeqr2_rank_0,&
      rocsolver_cgeqr2_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqr2
    function rocsolver_zgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqr2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqr2_full_rank,&
      rocsolver_zgeqr2_rank_0,&
      rocsolver_zgeqr2_rank_1
#endif
  end interface
  !>     \brief GEQR2_BATCHED computes the QR factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         R_j\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_k}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the diagonal contain the
  !>               factor R_j. The elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgeqr2_batched
    function rocsolver_sgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeqr2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqr2_batched_full_rank,&
      rocsolver_sgeqr2_batched_rank_0,&
      rocsolver_sgeqr2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqr2_batched
    function rocsolver_dgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeqr2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqr2_batched_full_rank,&
      rocsolver_dgeqr2_batched_rank_0,&
      rocsolver_dgeqr2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqr2_batched
    function rocsolver_cgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeqr2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqr2_batched_full_rank,&
      rocsolver_cgeqr2_batched_rank_0,&
      rocsolver_cgeqr2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqr2_batched
    function rocsolver_zgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeqr2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqr2_batched_full_rank,&
      rocsolver_zgeqr2_batched_rank_0,&
      rocsolver_zgeqr2_batched_rank_1
#endif
  end interface
  !>     \brief GEQR2_STRIDED_BATCHED computes the QR factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         R_j\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_k}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the diagonal contain the
  !>               factor R_j. The elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgeqr2_strided_batched
    function rocsolver_sgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeqr2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqr2_strided_batched_full_rank,&
      rocsolver_sgeqr2_strided_batched_rank_0,&
      rocsolver_sgeqr2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqr2_strided_batched
    function rocsolver_dgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeqr2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqr2_strided_batched_full_rank,&
      rocsolver_dgeqr2_strided_batched_rank_0,&
      rocsolver_dgeqr2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqr2_strided_batched
    function rocsolver_cgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeqr2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqr2_strided_batched_full_rank,&
      rocsolver_cgeqr2_strided_batched_rank_0,&
      rocsolver_cgeqr2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqr2_strided_batched
    function rocsolver_zgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeqr2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqr2_strided_batched_full_rank,&
      rocsolver_zgeqr2_strided_batched_rank_0,&
      rocsolver_zgeqr2_strided_batched_rank_1
#endif
  end interface
  !>     \brief GERQ2 computes a RQ factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = \left[\begin{array}{cc}
  !>         0 & R
  !>         \end{array}\right] Q
  !>     \f]
  !> 
  !>     where R is upper triangular (upper trapezoidal if m > n), and Q is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_1'H_2' \cdots H_k', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i v_i'
  !>     \f]
  !> 
  !>     where the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and above the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor R; the elements below the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgerq2
    function rocsolver_sgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgerq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgerq2_full_rank,&
      rocsolver_sgerq2_rank_0,&
      rocsolver_sgerq2_rank_1
#endif
  end interface
  
  interface rocsolver_dgerq2
    function rocsolver_dgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgerq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgerq2_full_rank,&
      rocsolver_dgerq2_rank_0,&
      rocsolver_dgerq2_rank_1
#endif
  end interface
  
  interface rocsolver_cgerq2
    function rocsolver_cgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgerq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgerq2_full_rank,&
      rocsolver_cgerq2_rank_0,&
      rocsolver_cgerq2_rank_1
#endif
  end interface
  
  interface rocsolver_zgerq2
    function rocsolver_zgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgerq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgerq2_full_rank,&
      rocsolver_zgerq2_rank_0,&
      rocsolver_zgerq2_rank_1
#endif
  end interface
  !>     \brief GERQ2_BATCHED computes the RQ factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         0 & R_j
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}'H_{j_2}' \cdots H_{j_k}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last n-i elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor R_j; the elements below the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgerq2_batched
    function rocsolver_sgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgerq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgerq2_batched_full_rank,&
      rocsolver_sgerq2_batched_rank_0,&
      rocsolver_sgerq2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgerq2_batched
    function rocsolver_dgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgerq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgerq2_batched_full_rank,&
      rocsolver_dgerq2_batched_rank_0,&
      rocsolver_dgerq2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgerq2_batched
    function rocsolver_cgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgerq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgerq2_batched_full_rank,&
      rocsolver_cgerq2_batched_rank_0,&
      rocsolver_cgerq2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgerq2_batched
    function rocsolver_zgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgerq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgerq2_batched_full_rank,&
      rocsolver_zgerq2_batched_rank_0,&
      rocsolver_zgerq2_batched_rank_1
#endif
  end interface
  !>     \brief GERQ2_STRIDED_BATCHED computes the RQ factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         0 & R_j
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}'H_{j_2}' \cdots H_{j_k}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last n-i elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor R_j; the elements below the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgerq2_strided_batched
    function rocsolver_sgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgerq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgerq2_strided_batched_full_rank,&
      rocsolver_sgerq2_strided_batched_rank_0,&
      rocsolver_sgerq2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgerq2_strided_batched
    function rocsolver_dgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgerq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgerq2_strided_batched_full_rank,&
      rocsolver_dgerq2_strided_batched_rank_0,&
      rocsolver_dgerq2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgerq2_strided_batched
    function rocsolver_cgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgerq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgerq2_strided_batched_full_rank,&
      rocsolver_cgerq2_strided_batched_rank_0,&
      rocsolver_cgerq2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgerq2_strided_batched
    function rocsolver_zgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgerq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgerq2_strided_batched_full_rank,&
      rocsolver_zgerq2_strided_batched_rank_0,&
      rocsolver_zgerq2_strided_batched_rank_1
#endif
  end interface
  !>     \brief GEQL2 computes a QL factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = Q\left[\begin{array}{c}
  !>         0\newline
  !>
  !>         L
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where L is lower triangular (lower trapezoidal if m < n), and Q is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i v_i'
  !>     \f]
  !> 
  !>     where the last m-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and below the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor L; the elements above the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgeql2
    function rocsolver_sgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeql2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeql2_full_rank,&
      rocsolver_sgeql2_rank_0,&
      rocsolver_sgeql2_rank_1
#endif
  end interface
  
  interface rocsolver_dgeql2
    function rocsolver_dgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeql2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeql2_full_rank,&
      rocsolver_dgeql2_rank_0,&
      rocsolver_dgeql2_rank_1
#endif
  end interface
  
  interface rocsolver_cgeql2
    function rocsolver_cgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeql2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeql2_full_rank,&
      rocsolver_cgeql2_rank_0,&
      rocsolver_cgeql2_rank_1
#endif
  end interface
  
  interface rocsolver_zgeql2
    function rocsolver_zgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeql2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeql2_full_rank,&
      rocsolver_zgeql2_rank_0,&
      rocsolver_zgeql2_rank_1
#endif
  end interface
  !>     \brief GEQL2_BATCHED computes the QL factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         0\newline
  !>
  !>         L_j
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_{j_k}H_{j_{k-1}}\cdots H_{j_1}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last m-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor L_j; the elements above the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgeql2_batched
    function rocsolver_sgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeql2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeql2_batched_full_rank,&
      rocsolver_sgeql2_batched_rank_0,&
      rocsolver_sgeql2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeql2_batched
    function rocsolver_dgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeql2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeql2_batched_full_rank,&
      rocsolver_dgeql2_batched_rank_0,&
      rocsolver_dgeql2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeql2_batched
    function rocsolver_cgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeql2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeql2_batched_full_rank,&
      rocsolver_cgeql2_batched_rank_0,&
      rocsolver_cgeql2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeql2_batched
    function rocsolver_zgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeql2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeql2_batched_full_rank,&
      rocsolver_zgeql2_batched_rank_0,&
      rocsolver_zgeql2_batched_rank_1
#endif
  end interface
  !>     \brief GEQL2_STRIDED_BATCHED computes the QL factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         0\newline
  !>
  !>         L_j
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_{j_k}H_{j_{k-1}}\cdots H_{j_1}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last m-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor L_j; the elements above the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgeql2_strided_batched
    function rocsolver_sgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeql2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeql2_strided_batched_full_rank,&
      rocsolver_sgeql2_strided_batched_rank_0,&
      rocsolver_sgeql2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeql2_strided_batched
    function rocsolver_dgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeql2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeql2_strided_batched_full_rank,&
      rocsolver_dgeql2_strided_batched_rank_0,&
      rocsolver_dgeql2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeql2_strided_batched
    function rocsolver_cgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeql2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeql2_strided_batched_full_rank,&
      rocsolver_cgeql2_strided_batched_rank_0,&
      rocsolver_cgeql2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeql2_strided_batched
    function rocsolver_zgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeql2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeql2_strided_batched_full_rank,&
      rocsolver_zgeql2_strided_batched_rank_0,&
      rocsolver_zgeql2_strided_batched_rank_1
#endif
  end interface
  !>     \brief GELQ2 computes a LQ factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = \left[\begin{array}{cc}
  !>         L & 0
  !>         \end{array}\right] Q
  !>     \f]
  !> 
  !>     where L is lower triangular (lower trapezoidal if m > n), and Q is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_k'H_{k-1}' \cdots H_1', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i' v_i
  !>     \f]
  !> 
  !>     where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and below the diagonal contain the
  !>               factor L; the elements above the diagonal are the last n - i elements
  !>               of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgelq2
    function rocsolver_sgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgelq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgelq2_full_rank,&
      rocsolver_sgelq2_rank_0,&
      rocsolver_sgelq2_rank_1
#endif
  end interface
  
  interface rocsolver_dgelq2
    function rocsolver_dgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgelq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgelq2_full_rank,&
      rocsolver_dgelq2_rank_0,&
      rocsolver_dgelq2_rank_1
#endif
  end interface
  
  interface rocsolver_cgelq2
    function rocsolver_cgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgelq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgelq2_full_rank,&
      rocsolver_cgelq2_rank_0,&
      rocsolver_cgelq2_rank_1
#endif
  end interface
  
  interface rocsolver_zgelq2
    function rocsolver_zgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgelq2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgelq2_full_rank,&
      rocsolver_zgelq2_rank_0,&
      rocsolver_zgelq2_rank_1
#endif
  end interface
  !>     \brief GELQ2_BATCHED computes the LQ factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         L_j & 0
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_k}'H_{j_{k-1}}' \cdots H_{j_1}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i}' v_{j_i}
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the diagonal contain the
  !>               factor L_j. The elements above the diagonal are the last n - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgelq2_batched
    function rocsolver_sgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgelq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgelq2_batched_full_rank,&
      rocsolver_sgelq2_batched_rank_0,&
      rocsolver_sgelq2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgelq2_batched
    function rocsolver_dgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgelq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgelq2_batched_full_rank,&
      rocsolver_dgelq2_batched_rank_0,&
      rocsolver_dgelq2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgelq2_batched
    function rocsolver_cgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgelq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgelq2_batched_full_rank,&
      rocsolver_cgelq2_batched_rank_0,&
      rocsolver_cgelq2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgelq2_batched
    function rocsolver_zgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgelq2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgelq2_batched_full_rank,&
      rocsolver_zgelq2_batched_rank_0,&
      rocsolver_zgelq2_batched_rank_1
#endif
  end interface
  !>     \brief GELQ2_STRIDED_BATCHED computes the LQ factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         L_j & 0
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_k}'H_{j_{k-1}}' \cdots H_{j_1}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i}' v_{j_i}
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the diagonal contain the
  !>               factor L_j. The elements above the diagonal are the last n - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgelq2_strided_batched
    function rocsolver_sgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgelq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgelq2_strided_batched_full_rank,&
      rocsolver_sgelq2_strided_batched_rank_0,&
      rocsolver_sgelq2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgelq2_strided_batched
    function rocsolver_dgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgelq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgelq2_strided_batched_full_rank,&
      rocsolver_dgelq2_strided_batched_rank_0,&
      rocsolver_dgelq2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgelq2_strided_batched
    function rocsolver_cgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgelq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgelq2_strided_batched_full_rank,&
      rocsolver_cgelq2_strided_batched_rank_0,&
      rocsolver_cgelq2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgelq2_strided_batched
    function rocsolver_zgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgelq2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgelq2_strided_batched_full_rank,&
      rocsolver_zgelq2_strided_batched_rank_0,&
      rocsolver_zgelq2_strided_batched_rank_1
#endif
  end interface
  !>     \brief GEQRF computes a QR factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = Q\left[\begin{array}{c}
  !>         R\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where R is upper triangular (upper trapezoidal if m < n), and Q is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_1H_2\cdots H_k, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i v_i'
  !>     \f]
  !> 
  !>     where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and above the diagonal contain the
  !>               factor R; the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgeqrf
    function rocsolver_sgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqrf_full_rank,&
      rocsolver_sgeqrf_rank_0,&
      rocsolver_sgeqrf_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqrf
    function rocsolver_dgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqrf_full_rank,&
      rocsolver_dgeqrf_rank_0,&
      rocsolver_dgeqrf_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqrf
    function rocsolver_cgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqrf_full_rank,&
      rocsolver_cgeqrf_rank_0,&
      rocsolver_cgeqrf_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqrf
    function rocsolver_zgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqrf_full_rank,&
      rocsolver_zgeqrf_rank_0,&
      rocsolver_zgeqrf_rank_1
#endif
  end interface
  !>     \brief GEQRF_BATCHED computes the QR factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         R_j\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_k}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the diagonal contain the
  !>               factor R_j. The elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgeqrf_batched
    function rocsolver_sgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeqrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqrf_batched_full_rank,&
      rocsolver_sgeqrf_batched_rank_0,&
      rocsolver_sgeqrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqrf_batched
    function rocsolver_dgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeqrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqrf_batched_full_rank,&
      rocsolver_dgeqrf_batched_rank_0,&
      rocsolver_dgeqrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqrf_batched
    function rocsolver_cgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeqrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqrf_batched_full_rank,&
      rocsolver_cgeqrf_batched_rank_0,&
      rocsolver_cgeqrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqrf_batched
    function rocsolver_zgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeqrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqrf_batched_full_rank,&
      rocsolver_zgeqrf_batched_rank_0,&
      rocsolver_zgeqrf_batched_rank_1
#endif
  end interface
  !>     \brief GEQRF_STRIDED_BATCHED computes the QR factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         R_j\newline
  !>
  !>         0
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_k}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the diagonal contain the
  !>               factor R_j. The elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgeqrf_strided_batched
    function rocsolver_sgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeqrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqrf_strided_batched_full_rank,&
      rocsolver_sgeqrf_strided_batched_rank_0,&
      rocsolver_sgeqrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqrf_strided_batched
    function rocsolver_dgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeqrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqrf_strided_batched_full_rank,&
      rocsolver_dgeqrf_strided_batched_rank_0,&
      rocsolver_dgeqrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqrf_strided_batched
    function rocsolver_cgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeqrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqrf_strided_batched_full_rank,&
      rocsolver_cgeqrf_strided_batched_rank_0,&
      rocsolver_cgeqrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqrf_strided_batched
    function rocsolver_zgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeqrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqrf_strided_batched_full_rank,&
      rocsolver_zgeqrf_strided_batched_rank_0,&
      rocsolver_zgeqrf_strided_batched_rank_1
#endif
  end interface
  !>     \brief GERQF computes a RQ factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = \left[\begin{array}{cc}
  !>         0 & R
  !>         \end{array}\right] Q
  !>     \f]
  !> 
  !>     where R is upper triangular (upper trapezoidal if m > n), and Q is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_1'H_2' \cdots H_k', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i v_i'
  !>     \f]
  !> 
  !>     where the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and above the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor R; the elements below the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgerqf
    function rocsolver_sgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgerqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgerqf_full_rank,&
      rocsolver_sgerqf_rank_0,&
      rocsolver_sgerqf_rank_1
#endif
  end interface
  
  interface rocsolver_dgerqf
    function rocsolver_dgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgerqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgerqf_full_rank,&
      rocsolver_dgerqf_rank_0,&
      rocsolver_dgerqf_rank_1
#endif
  end interface
  
  interface rocsolver_cgerqf
    function rocsolver_cgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgerqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgerqf_full_rank,&
      rocsolver_cgerqf_rank_0,&
      rocsolver_cgerqf_rank_1
#endif
  end interface
  
  interface rocsolver_zgerqf
    function rocsolver_zgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgerqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgerqf_full_rank,&
      rocsolver_zgerqf_rank_0,&
      rocsolver_zgerqf_rank_1
#endif
  end interface
  !>     \brief GERQF_BATCHED computes the RQ factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         0 & R_j
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}'H_{j_2}' \cdots H_{j_k}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last n-i elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor R_j; the elements below the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgerqf_batched
    function rocsolver_sgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgerqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgerqf_batched_full_rank,&
      rocsolver_sgerqf_batched_rank_0,&
      rocsolver_sgerqf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgerqf_batched
    function rocsolver_dgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgerqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgerqf_batched_full_rank,&
      rocsolver_dgerqf_batched_rank_0,&
      rocsolver_dgerqf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgerqf_batched
    function rocsolver_cgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgerqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgerqf_batched_full_rank,&
      rocsolver_cgerqf_batched_rank_0,&
      rocsolver_cgerqf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgerqf_batched
    function rocsolver_zgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgerqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgerqf_batched_full_rank,&
      rocsolver_zgerqf_batched_rank_0,&
      rocsolver_zgerqf_batched_rank_1
#endif
  end interface
  !>     \brief GERQF_STRIDED_BATCHED computes the RQ factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         0 & R_j
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$R_j\f$ is upper triangular (upper trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_1}'H_{j_2}' \cdots H_{j_k}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last n-i elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and above the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor R_j; the elements below the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgerqf_strided_batched
    function rocsolver_sgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgerqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgerqf_strided_batched_full_rank,&
      rocsolver_sgerqf_strided_batched_rank_0,&
      rocsolver_sgerqf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgerqf_strided_batched
    function rocsolver_dgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgerqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgerqf_strided_batched_full_rank,&
      rocsolver_dgerqf_strided_batched_rank_0,&
      rocsolver_dgerqf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgerqf_strided_batched
    function rocsolver_cgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgerqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgerqf_strided_batched_full_rank,&
      rocsolver_cgerqf_strided_batched_rank_0,&
      rocsolver_cgerqf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgerqf_strided_batched
    function rocsolver_zgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgerqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgerqf_strided_batched_full_rank,&
      rocsolver_zgerqf_strided_batched_rank_0,&
      rocsolver_zgerqf_strided_batched_rank_1
#endif
  end interface
  !>     \brief GEQLF computes a QL factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = Q\left[\begin{array}{c}
  !>         0\newline
  !>
  !>         L
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where L is lower triangular (lower trapezoidal if m < n), and Q is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_kH_{k-1}\cdots H_1, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i v_i'
  !>     \f]
  !> 
  !>     where the last m-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and below the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor L; the elements above the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  interface rocsolver_sgeqlf
    function rocsolver_sgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqlf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqlf_full_rank,&
      rocsolver_sgeqlf_rank_0,&
      rocsolver_sgeqlf_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqlf
    function rocsolver_dgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqlf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqlf_full_rank,&
      rocsolver_dgeqlf_rank_0,&
      rocsolver_dgeqlf_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqlf
    function rocsolver_cgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqlf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqlf_full_rank,&
      rocsolver_cgeqlf_rank_0,&
      rocsolver_cgeqlf_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqlf
    function rocsolver_zgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqlf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqlf_full_rank,&
      rocsolver_zgeqlf_rank_0,&
      rocsolver_zgeqlf_rank_1
#endif
  end interface
  !>     \brief GEQLF_BATCHED computes the QL factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         0\newline
  !>
  !>         L_j
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_{j_k}H_{j_{k-1}}\cdots H_{j_1}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last m-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor L_j; the elements above the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgeqlf_batched
    function rocsolver_sgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeqlf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqlf_batched_full_rank,&
      rocsolver_sgeqlf_batched_rank_0,&
      rocsolver_sgeqlf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqlf_batched
    function rocsolver_dgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeqlf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqlf_batched_full_rank,&
      rocsolver_dgeqlf_batched_rank_0,&
      rocsolver_dgeqlf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqlf_batched
    function rocsolver_cgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeqlf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqlf_batched_full_rank,&
      rocsolver_cgeqlf_batched_rank_0,&
      rocsolver_cgeqlf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqlf_batched
    function rocsolver_zgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeqlf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqlf_batched_full_rank,&
      rocsolver_zgeqlf_batched_rank_0,&
      rocsolver_zgeqlf_batched_rank_1
#endif
  end interface
  !>     \brief GEQLF_STRIDED_BATCHED computes the QL factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = Q_j\left[\begin{array}{c}
  !>         0\newline
  !>
  !>         L_j
  !>         \end{array}\right]
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m < n), and \f$Q_j\f$ is
  !>     a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_{j_k}H_{j_{k-1}}\cdots H_{j_1}, \quad \text{with} \: k = \text{min}(m,n)
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i} v_{j_i}'
  !>     \f]
  !> 
  !>     where the last m-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the (m-n)-th subdiagonal (when
  !>               m >= n) or the (n-m)-th superdiagonal (when n > m) contain the
  !>               factor L_j; the elements above the sub/superdiagonal are the first i - 1
  !>               elements of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgeqlf_strided_batched
    function rocsolver_sgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgeqlf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgeqlf_strided_batched_full_rank,&
      rocsolver_sgeqlf_strided_batched_rank_0,&
      rocsolver_sgeqlf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgeqlf_strided_batched
    function rocsolver_dgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgeqlf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgeqlf_strided_batched_full_rank,&
      rocsolver_dgeqlf_strided_batched_rank_0,&
      rocsolver_dgeqlf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgeqlf_strided_batched
    function rocsolver_cgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgeqlf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgeqlf_strided_batched_full_rank,&
      rocsolver_cgeqlf_strided_batched_rank_0,&
      rocsolver_cgeqlf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgeqlf_strided_batched
    function rocsolver_zgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgeqlf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgeqlf_strided_batched_full_rank,&
      rocsolver_zgeqlf_strided_batched_rank_0,&
      rocsolver_zgeqlf_strided_batched_rank_1
#endif
  end interface
  !>     \brief GELQF computes a LQ factorization of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         A = \left[\begin{array}{cc}
  !>         L & 0
  !>         \end{array}\right] Q
  !>     \f]
  !> 
  !>     where L is lower triangular (lower trapezoidal if m > n), and Q is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q = H_k'H_{k-1}' \cdots H_1', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{ipiv}[i] \cdot v_i' v_i
  !>     \f]
  !> 
  !>     where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on and below the diagonal contain the
  !>               factor L; the elements above the diagonal are the last n - i elements
  !>               of Householder vector v_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars.
  !>
  interface rocsolver_sgelqf
    function rocsolver_sgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgelqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgelqf_full_rank,&
      rocsolver_sgelqf_rank_0,&
      rocsolver_sgelqf_rank_1
#endif
  end interface
  
  interface rocsolver_dgelqf
    function rocsolver_dgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgelqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgelqf_full_rank,&
      rocsolver_dgelqf_rank_0,&
      rocsolver_dgelqf_rank_1
#endif
  end interface
  
  interface rocsolver_cgelqf
    function rocsolver_cgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgelqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgelqf_full_rank,&
      rocsolver_cgelqf_rank_0,&
      rocsolver_cgelqf_rank_1
#endif
  end interface
  
  interface rocsolver_zgelqf
    function rocsolver_zgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgelqf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgelqf_full_rank,&
      rocsolver_zgelqf_rank_0,&
      rocsolver_zgelqf_rank_1
#endif
  end interface
  !>     \brief GELQF_BATCHED computes the LQ factorization of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         L_j & 0
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_k}'H_{j_{k-1}}' \cdots H_{j_1}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i}' v_{j_i}
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the diagonal contain the
  !>               factor L_j. The elements above the diagonal are the last n - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgelqf_batched
    function rocsolver_sgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgelqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgelqf_batched_full_rank,&
      rocsolver_sgelqf_batched_rank_0,&
      rocsolver_sgelqf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgelqf_batched
    function rocsolver_dgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgelqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgelqf_batched_full_rank,&
      rocsolver_dgelqf_batched_rank_0,&
      rocsolver_dgelqf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgelqf_batched
    function rocsolver_cgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgelqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgelqf_batched_full_rank,&
      rocsolver_cgelqf_batched_rank_0,&
      rocsolver_cgelqf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgelqf_batched
    function rocsolver_zgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgelqf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgelqf_batched_full_rank,&
      rocsolver_zgelqf_batched_rank_0,&
      rocsolver_zgelqf_batched_rank_1
#endif
  end interface
  !>     \brief GELQF_STRIDED_BATCHED computes the LQ factorization of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_j\f$ in the batch has the form
  !> 
  !>     \f[
  !>         A_j = \left[\begin{array}{cc}
  !>         L_j & 0
  !>         \end{array}\right] Q_j
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is lower triangular (lower trapezoidal if m > n), and \f$Q_j\f$ is
  !>     a n-by-n orthogonal/unitary matrix represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         Q_j = H_{j_k}'H_{j_{k-1}}' \cdots H_{j_1}', \quad \text{with} \: k = \text{min}(m,n).
  !>     \f]
  !> 
  !>     Each Householder matrices \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{ipiv}_j[i] \cdot v_{j_i}' v_{j_i}
  !>     \f]
  !> 
  !>     where the first i-1 elements of Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on and below the diagonal contain the
  !>               factor L_j. The elements above the diagonal are the last n - i elements
  !>               of Householder vector v_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors ipiv_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  interface rocsolver_sgelqf_strided_batched
    function rocsolver_sgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_sgelqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgelqf_strided_batched_full_rank,&
      rocsolver_sgelqf_strided_batched_rank_0,&
      rocsolver_sgelqf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgelqf_strided_batched
    function rocsolver_dgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_dgelqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgelqf_strided_batched_full_rank,&
      rocsolver_dgelqf_strided_batched_rank_0,&
      rocsolver_dgelqf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgelqf_strided_batched
    function rocsolver_cgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_cgelqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgelqf_strided_batched_full_rank,&
      rocsolver_cgelqf_strided_batched_rank_0,&
      rocsolver_cgelqf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgelqf_strided_batched
    function rocsolver_zgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) bind(c, name="rocsolver_zgelqf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgelqf_strided_batched_full_rank,&
      rocsolver_zgelqf_strided_batched_rank_0,&
      rocsolver_zgelqf_strided_batched_rank_1
#endif
  end interface
  !>     \brief GEBD2 computes the bidiagonal form of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The bidiagonal form is given by:
  !> 
  !>     \f[
  !>         B = Q'  A  P
  !>     \f]
  !> 
  !>     where B is upper bidiagonal if m >= n and lower bidiagonal if m < n, and Q and
  !>     P are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_n\:  \text{and} \: P = G_1G_2\cdots G_{n-1}, & \: \text{if}\: m >= n, \:\text{or}\newline
  !>
  !>         Q = H_1H_2\cdots H_{m-1}\:  \text{and} \: P = G_1G_2\cdots G_{m}, & \: \text{if}\: m < n.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ and \f$G_i\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_i = I - \text{tauq}[i] \cdot v_i v_i', & \: \text{and}\newline
  !>
  !>         G_i = I - \text{taup}[i] \cdot u_i' u_i.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$;
  !>     while the first i elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i+1] = 1\f$.
  !>     If m < n, the first i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n) contain the bidiagonal form B.
  !>               If m >= n, the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_i, and the elements above the
  !>               superdiagonal are the last n - i - 1 elements of Householder vector u_i.
  !>               If m < n, the elements below the subdiagonal are the last m - i - 1
  !>               elements of Householder vector v_i, and the elements above the
  !>               diagonal are the last n - i elements of Householder vector u_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               specifies the leading dimension of A.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension min(m,n).\n
  !>               The diagonal elements of B.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension min(m,n)-1.\n
  !>               The off-diagonal elements of B.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars associated with matrix Q.
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars associated with matrix P.
  !>
  interface rocsolver_sgebd2
    function rocsolver_sgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_sgebd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgebd2_full_rank,&
      rocsolver_sgebd2_rank_0,&
      rocsolver_sgebd2_rank_1
#endif
  end interface
  
  interface rocsolver_dgebd2
    function rocsolver_dgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_dgebd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgebd2_full_rank,&
      rocsolver_dgebd2_rank_0,&
      rocsolver_dgebd2_rank_1
#endif
  end interface
  
  interface rocsolver_cgebd2
    function rocsolver_cgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_cgebd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgebd2_full_rank,&
      rocsolver_cgebd2_rank_0,&
      rocsolver_cgebd2_rank_1
#endif
  end interface
  
  interface rocsolver_zgebd2
    function rocsolver_zgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_zgebd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgebd2_full_rank,&
      rocsolver_zgebd2_rank_0,&
      rocsolver_zgebd2_rank_1
#endif
  end interface
  !>     \brief GEBD2_BATCHED computes the bidiagonal form of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the bidiagonal form is given by:
  !> 
  !>     \f[
  !>         B_j = Q_j'  A_j  P_j
  !>     \f]
  !> 
  !>     where \f$B_j\f$ is upper bidiagonal if m >= n and lower bidiagonal if m < n, and \f$Q_j\f$ and
  !>     \f$P_j\f$ are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_n}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_{n-1}}, & \: \text{if}\: m >= n, \:\text{or}\newline
  !>
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{m-1}}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_m}, & \: \text{if}\: m < n.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ and \f$G_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_{j_i} = I - \text{tauq}_j[i] \cdot v_{j_i} v_{j_i}', & \: \text{and}\newline
  !>
  !>         G_{j_i} = I - \text{taup}_j[i] \cdot u_{j_i}' u_{j_i}.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$;
  !>     while the first i elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i+1] = 1\f$.
  !>     If m < n, the first i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n) contain the bidiagonal form B_j.
  !>               If m >= n, the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i), and the elements above the
  !>               superdiagonal are the last n - i - 1 elements of Householder vector u_(j_i).
  !>               If m < n, the elements below the subdiagonal are the last m - i - 1
  !>               elements of Householder vector v_(j_i), and the elements above the
  !>               diagonal are the last n - i elements of Householder vector u_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of B_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= min(m,n).
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of B_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU (the size depends on the value of strideQ).\n
  !>               Contains the vectors tauq_j of Householder scalars associated with matrices Q_j.
  !>     @param[in]
  !>     strideQ   rocblas_stride.\n
  !>               Stride from the start of one vector tauq_j to the next one tauq_(j+1).
  !>               There is no restriction for the value
  !>               of strideQ. Normal use is strideQ >= min(m,n).
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors taup_j of Householder scalars associated with matrices P_j.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector taup_j to the next one taup_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgebd2_batched
    function rocsolver_sgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_sgebd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgebd2_batched_full_rank,&
      rocsolver_sgebd2_batched_rank_0,&
      rocsolver_sgebd2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgebd2_batched
    function rocsolver_dgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_dgebd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgebd2_batched_full_rank,&
      rocsolver_dgebd2_batched_rank_0,&
      rocsolver_dgebd2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgebd2_batched
    function rocsolver_cgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_cgebd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgebd2_batched_full_rank,&
      rocsolver_cgebd2_batched_rank_0,&
      rocsolver_cgebd2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgebd2_batched
    function rocsolver_zgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_zgebd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgebd2_batched_full_rank,&
      rocsolver_zgebd2_batched_rank_0,&
      rocsolver_zgebd2_batched_rank_1
#endif
  end interface
  !>     \brief GEBD2_STRIDED_BATCHED computes the bidiagonal form of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the bidiagonal form is given by:
  !> 
  !>     \f[
  !>         B_j = Q_j'  A_j  P_j
  !>     \f]
  !> 
  !>     where \f$B_j\f$ is upper bidiagonal if m >= n and lower bidiagonal if m < n, and \f$Q_j\f$ and
  !>     \f$P_j\f$ are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_n}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_{n-1}}, & \: \text{if}\: m >= n, \:\text{or}\newline
  !>
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{m-1}}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_m}, & \: \text{if}\: m < n.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ and \f$G_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_{j_i} = I - \text{tauq}_j[i] \cdot v_{j_i} v_{j_i}', & \: \text{and}\newline
  !>
  !>         G_{j_i} = I - \text{taup}_j[i] \cdot u_{j_i}' u_{j_i}.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$;
  !>     while the first i elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i+1] = 1\f$.
  !>     If m < n, the first i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n) contain the bidiagonal form B_j.
  !>               If m >= n, the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i), and the elements above the
  !>               superdiagonal are the last n - i - 1 elements of Householder vector u_(j_i).
  !>               If m < n, the elements below the subdiagonal are the last m - i - 1
  !>               elements of Householder vector v_(j_i), and the elements above the
  !>               diagonal are the last n - i elements of Householder vector u_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of B_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= min(m,n).
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of B_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU (the size depends on the value of strideQ).\n
  !>               Contains the vectors tauq_j of Householder scalars associated with matrices Q_j.
  !>     @param[in]
  !>     strideQ   rocblas_stride.\n
  !>               Stride from the start of one vector tauq_j to the next one tauq_(j+1).
  !>               There is no restriction for the value
  !>               of strideQ. Normal use is strideQ >= min(m,n).
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors taup_j of Householder scalars associated with matrices P_j.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector taup_j to the next one taup_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgebd2_strided_batched
    function rocsolver_sgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_sgebd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgebd2_strided_batched_full_rank,&
      rocsolver_sgebd2_strided_batched_rank_0,&
      rocsolver_sgebd2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgebd2_strided_batched
    function rocsolver_dgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_dgebd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgebd2_strided_batched_full_rank,&
      rocsolver_dgebd2_strided_batched_rank_0,&
      rocsolver_dgebd2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgebd2_strided_batched
    function rocsolver_cgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_cgebd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgebd2_strided_batched_full_rank,&
      rocsolver_cgebd2_strided_batched_rank_0,&
      rocsolver_cgebd2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgebd2_strided_batched
    function rocsolver_zgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_zgebd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgebd2_strided_batched_full_rank,&
      rocsolver_zgebd2_strided_batched_rank_0,&
      rocsolver_zgebd2_strided_batched_rank_1
#endif
  end interface
  !>     \brief GEBRD computes the bidiagonal form of a general m-by-n matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The bidiagonal form is given by:
  !> 
  !>     \f[
  !>         B = Q'  A  P
  !>     \f]
  !> 
  !>     where B is upper bidiagonal if m >= n and lower bidiagonal if m < n, and Q and
  !>     P are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_n\:  \text{and} \: P = G_1G_2\cdots G_{n-1}, & \: \text{if}\: m >= n, \:\text{or}\newline
  !>
  !>         Q = H_1H_2\cdots H_{m-1}\:  \text{and} \: P = G_1G_2\cdots G_{m}, & \: \text{if}\: m < n.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ and \f$G_i\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_i = I - \text{tauq}[i] \cdot v_i v_i', & \: \text{and}\newline
  !>
  !>         G_i = I - \text{taup}[i] \cdot u_i' u_i.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$;
  !>     while the first i elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i+1] = 1\f$.
  !>     If m < n, the first i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of the matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrix to be factored.
  !>               On exit, the elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n) contain the bidiagonal form B.
  !>               If m >= n, the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_i, and the elements above the
  !>               superdiagonal are the last n - i - 1 elements of Householder vector u_i.
  !>               If m < n, the elements below the subdiagonal are the last m - i - 1
  !>               elements of Householder vector v_i, and the elements above the
  !>               diagonal are the last n - i elements of Householder vector u_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               specifies the leading dimension of A.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension min(m,n).\n
  !>               The diagonal elements of B.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension min(m,n)-1.\n
  !>               The off-diagonal elements of B.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars associated with matrix Q.
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU of dimension min(m,n).\n
  !>               The Householder scalars associated with matrix P.
  !>
  interface rocsolver_sgebrd
    function rocsolver_sgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_sgebrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgebrd_full_rank,&
      rocsolver_sgebrd_rank_0,&
      rocsolver_sgebrd_rank_1
#endif
  end interface
  
  interface rocsolver_dgebrd
    function rocsolver_dgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_dgebrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgebrd_full_rank,&
      rocsolver_dgebrd_rank_0,&
      rocsolver_dgebrd_rank_1
#endif
  end interface
  
  interface rocsolver_cgebrd
    function rocsolver_cgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_cgebrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgebrd_full_rank,&
      rocsolver_cgebrd_rank_0,&
      rocsolver_cgebrd_rank_1
#endif
  end interface
  
  interface rocsolver_zgebrd
    function rocsolver_zgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_zgebrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      type(c_ptr),value :: tauq
      type(c_ptr),value :: taup
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgebrd_full_rank,&
      rocsolver_zgebrd_rank_0,&
      rocsolver_zgebrd_rank_1
#endif
  end interface
  !>     \brief GEBRD_BATCHED computes the bidiagonal form of a batch of general
  !>     m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the bidiagonal form is given by:
  !> 
  !>     \f[
  !>         B_j = Q_j'  A_j  P_j
  !>     \f]
  !> 
  !>     where \f$B_j\f$ is upper bidiagonal if m >= n and lower bidiagonal if m < n, and \f$Q_j\f$ and
  !>     \f$P_j\f$ are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_n}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_{n-1}}, & \: \text{if}\: m >= n, \:\text{or}\newline
  !>
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{m-1}}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_m}, & \: \text{if}\: m < n.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ and \f$G_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_{j_i} = I - \text{tauq}_j[i] \cdot v_{j_i} v_{j_i}', & \: \text{and}\newline
  !>
  !>         G_{j_i} = I - \text{taup}_j[i] \cdot u_{j_i}' u_{j_i}.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$;
  !>     while the first i elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i+1] = 1\f$.
  !>     If m < n, the first i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n) contain the bidiagonal form B_j.
  !>               If m >= n, the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i), and the elements above the
  !>               superdiagonal are the last n - i - 1 elements of Householder vector u_(j_i).
  !>               If m < n, the elements below the subdiagonal are the last m - i - 1
  !>               elements of Householder vector v_(j_i), and the elements above the
  !>               diagonal are the last n - i elements of Householder vector u_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of B_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= min(m,n).
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of B_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU (the size depends on the value of strideQ).\n
  !>               Contains the vectors tauq_j of Householder scalars associated with matrices Q_j.
  !>     @param[in]
  !>     strideQ   rocblas_stride.\n
  !>               Stride from the start of one vector tauq_j to the next one tauq_(j+1).
  !>               There is no restriction for the value
  !>               of strideQ. Normal use is strideQ >= min(m,n).
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors taup_j of Householder scalars associated with matrices P_j.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector taup_j to the next one taup_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgebrd_batched
    function rocsolver_sgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_sgebrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgebrd_batched_full_rank,&
      rocsolver_sgebrd_batched_rank_0,&
      rocsolver_sgebrd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgebrd_batched
    function rocsolver_dgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_dgebrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgebrd_batched_full_rank,&
      rocsolver_dgebrd_batched_rank_0,&
      rocsolver_dgebrd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgebrd_batched
    function rocsolver_cgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_cgebrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgebrd_batched_full_rank,&
      rocsolver_cgebrd_batched_rank_0,&
      rocsolver_cgebrd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgebrd_batched
    function rocsolver_zgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_zgebrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgebrd_batched_full_rank,&
      rocsolver_zgebrd_batched_rank_0,&
      rocsolver_zgebrd_batched_rank_1
#endif
  end interface
  !>     \brief GEBRD_STRIDED_BATCHED computes the bidiagonal form of a batch of
  !>     general m-by-n matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the bidiagonal form is given by:
  !> 
  !>     \f[
  !>         B_j = Q_j'  A_j  P_j
  !>     \f]
  !> 
  !>     where \f$B_j\f$ is upper bidiagonal if m >= n and lower bidiagonal if m < n, and \f$Q_j\f$ and
  !>     \f$P_j\f$ are orthogonal/unitary matrices represented as the product of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_n}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_{n-1}}, & \: \text{if}\: m >= n, \:\text{or}\newline
  !>
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{m-1}}\:  \text{and} \: P_j = G_{j_1}G_{j_2}\cdots G_{j_m}, & \: \text{if}\: m < n.
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ and \f$G_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         H_{j_i} = I - \text{tauq}_j[i] \cdot v_{j_i} v_{j_i}', & \: \text{and}\newline
  !>
  !>         G_{j_i} = I - \text{taup}_j[i] \cdot u_{j_i}' u_{j_i}.
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n, the first i-1 elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$;
  !>     while the first i elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i+1] = 1\f$.
  !>     If m < n, the first i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$;
  !>     while the first i-1 elements of the Householder vector \f$u_{j_i}\f$ are zero, and \f$u_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all the matrices A_j in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all the matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the m-by-n matrices A_j to be factored.
  !>               On exit, the elements on the diagonal and superdiagonal (if m >= n), or
  !>               subdiagonal (if m < n) contain the bidiagonal form B_j.
  !>               If m >= n, the elements below the diagonal are the last m - i elements
  !>               of Householder vector v_(j_i), and the elements above the
  !>               superdiagonal are the last n - i - 1 elements of Householder vector u_(j_i).
  !>               If m < n, the elements below the subdiagonal are the last m - i - 1
  !>               elements of Householder vector v_(j_i), and the elements above the
  !>               diagonal are the last n - i elements of Householder vector u_(j_i).
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of B_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= min(m,n).
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of B_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
  !>     @param[out]
  !>     tauq      pointer to type. Array on the GPU (the size depends on the value of strideQ).\n
  !>               Contains the vectors tauq_j of Householder scalars associated with matrices Q_j.
  !>     @param[in]
  !>     strideQ   rocblas_stride.\n
  !>               Stride from the start of one vector tauq_j to the next one tauq_(j+1).
  !>               There is no restriction for the value
  !>               of strideQ. Normal use is strideQ >= min(m,n).
  !>     @param[out]
  !>     taup      pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors taup_j of Householder scalars associated with matrices P_j.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector taup_j to the next one taup_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= min(m,n).
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_sgebrd_strided_batched
    function rocsolver_sgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_sgebrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgebrd_strided_batched_full_rank,&
      rocsolver_sgebrd_strided_batched_rank_0,&
      rocsolver_sgebrd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgebrd_strided_batched
    function rocsolver_dgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_dgebrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgebrd_strided_batched_full_rank,&
      rocsolver_dgebrd_strided_batched_rank_0,&
      rocsolver_dgebrd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgebrd_strided_batched
    function rocsolver_cgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_cgebrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgebrd_strided_batched_full_rank,&
      rocsolver_cgebrd_strided_batched_rank_0,&
      rocsolver_cgebrd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgebrd_strided_batched
    function rocsolver_zgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count) bind(c, name="rocsolver_zgebrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      type(c_ptr),value :: tauq
      integer(c_int64_t),value :: strideQ
      type(c_ptr),value :: taup
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgebrd_strided_batched_full_rank,&
      rocsolver_zgebrd_strided_batched_rank_0,&
      rocsolver_zgebrd_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRS solves a system of n linear equations on n variables in its factorized form.
  !> 
  !>     \details
  !>     It solves one of the following systems, depending on the value of trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = B & \: \text{not transposed,}\newline
  !>
  !>         A^T X = B & \: \text{transposed, or}\newline
  !>
  !>         A^H X = B & \: \text{conjugate transposed.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Matrix A is defined by its triangular factors as returned by \ref rocsolver_sgetrf "GETRF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     trans       rocblas_operation.\n
  !>                 Specifies the form of the system of equations.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of A.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of the matrix B.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 The factors L and U of the factorization A = P*L*U returned by \ref rocsolver_sgetrf "GETRF".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of A.
  !>     @param[in]
  !>     ipiv        pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>                 The pivot indices returned by \ref rocsolver_sgetrf "GETRF".
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrix B.
  !>                 On exit, the solution matrix X.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of B.
  !>
  interface rocsolver_sgetrs
    function rocsolver_sgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_sgetrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrs_full_rank,&
      rocsolver_sgetrs_rank_0,&
      rocsolver_sgetrs_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrs
    function rocsolver_dgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_dgetrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrs_full_rank,&
      rocsolver_dgetrs_rank_0,&
      rocsolver_dgetrs_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrs
    function rocsolver_cgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_cgetrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrs_full_rank,&
      rocsolver_cgetrs_rank_0,&
      rocsolver_cgetrs_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrs
    function rocsolver_zgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_zgetrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrs_full_rank,&
      rocsolver_zgetrs_rank_0,&
      rocsolver_zgetrs_rank_1
#endif
  end interface
  !>     \brief GETRS_BATCHED solves a batch of systems of n linear equations on n
  !>     variables in its factorized forms.
  !> 
  !>     \details
  !>     For each instance j in the batch, it solves one of the following systems, depending on the value of trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_j X_j = B_j & \: \text{not transposed,}\newline
  !>
  !>         A_j^T X_j = B_j & \: \text{transposed, or}\newline
  !>
  !>         A_j^H X_j = B_j & \: \text{conjugate transposed.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Matrix \f$A_j\f$ is defined by its triangular factors as returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     trans       rocblas_operation.\n
  !>                 Specifies the form of the system of equations of each instance in the batch.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 The factors L_j and U_j of the factorization A_j = P_j*L_j*U_j returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in]
  !>     ipiv        pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>                 Contains the vectors ipiv_j of pivot indices returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     strideP     rocblas_stride.\n
  !>                 Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>                 There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[in,out]
  !>     B           Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_sgetrs_batched
    function rocsolver_sgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) bind(c, name="rocsolver_sgetrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrs_batched_full_rank,&
      rocsolver_sgetrs_batched_rank_0,&
      rocsolver_sgetrs_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrs_batched
    function rocsolver_dgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) bind(c, name="rocsolver_dgetrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrs_batched_full_rank,&
      rocsolver_dgetrs_batched_rank_0,&
      rocsolver_dgetrs_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrs_batched
    function rocsolver_cgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) bind(c, name="rocsolver_cgetrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrs_batched_full_rank,&
      rocsolver_cgetrs_batched_rank_0,&
      rocsolver_cgetrs_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrs_batched
    function rocsolver_zgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) bind(c, name="rocsolver_zgetrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrs_batched_full_rank,&
      rocsolver_zgetrs_batched_rank_0,&
      rocsolver_zgetrs_batched_rank_1
#endif
  end interface
  !>     \brief GETRS_STRIDED_BATCHED solves a batch of systems of n linear equations
  !>     on n variables in its factorized forms.
  !> 
  !>     \details
  !>     For each instance j in the batch, it solves one of the following systems, depending on the value of trans:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_j X_j = B_j & \: \text{not transposed,}\newline
  !>
  !>         A_j^T X_j = B_j & \: \text{transposed, or}\newline
  !>
  !>         A_j^H X_j = B_j & \: \text{conjugate transposed.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Matrix \f$A_j\f$ is defined by its triangular factors as returned by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     trans       rocblas_operation.\n
  !>                 Specifies the form of the system of equations of each instance in the batch.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 The factors L_j and U_j of the factorization A_j = P_j*L_j*U_j returned by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[in]
  !>     ipiv        pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>                 Contains the vectors ipiv_j of pivot indices returned by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     strideP     rocblas_stride.\n
  !>                 Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>                 There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU (size depends on the value of strideB).\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[in]
  !>     strideB     rocblas_stride.\n
  !>                 Stride from the start of one matrix B_j to the next one B_(j+1).
  !>                 There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_sgetrs_strided_batched
    function rocsolver_sgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count) bind(c, name="rocsolver_sgetrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetrs_strided_batched_full_rank,&
      rocsolver_sgetrs_strided_batched_rank_0,&
      rocsolver_sgetrs_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetrs_strided_batched
    function rocsolver_dgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count) bind(c, name="rocsolver_dgetrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetrs_strided_batched_full_rank,&
      rocsolver_dgetrs_strided_batched_rank_0,&
      rocsolver_dgetrs_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetrs_strided_batched
    function rocsolver_cgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count) bind(c, name="rocsolver_cgetrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetrs_strided_batched_full_rank,&
      rocsolver_cgetrs_strided_batched_rank_0,&
      rocsolver_cgetrs_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetrs_strided_batched
    function rocsolver_zgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count) bind(c, name="rocsolver_zgetrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetrs_strided_batched_full_rank,&
      rocsolver_zgetrs_strided_batched_rank_0,&
      rocsolver_zgetrs_strided_batched_rank_1
#endif
  end interface
  !>     \brief GESV solves a general system of n linear equations on n variables.
  !> 
  !>     \details
  !>     The linear system is of the form
  !> 
  !>     \f[
  !>         A X = B
  !>     \f]
  !> 
  !>     where A is a general n-by-n matrix. Matrix A is first factorized in triangular factors L and U
  !>     using \ref rocsolver_sgetrf "GETRF"; then, the solution is computed with \ref rocsolver_sgetrs "GETRS".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of A.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of the matrix B.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A.
  !>                 On exit, if info = 0, the factors L and U of the LU decomposition of A returned by
  !>                 \ref rocsolver_sgetrf "GETRF".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of A.
  !>     @param[out]
  !>     ipiv        pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>                 The pivot indices returned by \ref rocsolver_sgetrf "GETRF".
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrix B.
  !>                 On exit, the solution matrix X.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of B.
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit.
  !>                 If info = i > 0, U is singular, and the solution could not be computed.
  !>                 U[i,i] is the first zero element in the diagonal.
  !>
  interface rocsolver_sgesv
    function rocsolver_sgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_sgesv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgesv_full_rank,&
      rocsolver_sgesv_rank_0,&
      rocsolver_sgesv_rank_1
#endif
  end interface
  
  interface rocsolver_dgesv
    function rocsolver_dgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_dgesv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgesv_full_rank,&
      rocsolver_dgesv_rank_0,&
      rocsolver_dgesv_rank_1
#endif
  end interface
  
  interface rocsolver_cgesv
    function rocsolver_cgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_cgesv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgesv_full_rank,&
      rocsolver_cgesv_rank_0,&
      rocsolver_cgesv_rank_1
#endif
  end interface
  
  interface rocsolver_zgesv
    function rocsolver_zgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_zgesv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgesv_full_rank,&
      rocsolver_zgesv_rank_0,&
      rocsolver_zgesv_rank_1
#endif
  end interface
  !>     \brief GESV_BATCHED solves a batch of general systems of n linear equations on n
  !>     variables.
  !> 
  !>     \details
  !>     The linear systems are of the form
  !> 
  !>     \f[
  !>         A_j X_j = B_j
  !>     \f]
  !> 
  !>     where \f$A_j\f$ is a general n-by-n matrix. Matrix \f$A_j\f$ is first factorized in triangular factors \f$L_j\f$ and \f$U_j\f$
  !>     using \ref rocsolver_sgetrf_batched "GETRF_BATCHED"; then, the solutions are computed with \ref rocsolver_sgetrs_batched "GETRS_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrices A_j.
  !>                 On exit, if info_j = 0, the factors L_j and U_j of the LU decomposition of A_j returned by
  !>                 \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[out]
  !>     ipiv        pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>                 The vectors ipiv_j of pivot indices returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     strideP     rocblas_stride.\n
  !>                 Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>                 There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[in,out]
  !>     B           Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for A_j.
  !>                 If info[i] = j > 0, U_i is singular, and the solution could not be computed.
  !>                 U_j[i,i] is the first zero element in the diagonal.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_sgesv_batched
    function rocsolver_sgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_sgesv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgesv_batched_full_rank,&
      rocsolver_sgesv_batched_rank_0,&
      rocsolver_sgesv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgesv_batched
    function rocsolver_dgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_dgesv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgesv_batched_full_rank,&
      rocsolver_dgesv_batched_rank_0,&
      rocsolver_dgesv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgesv_batched
    function rocsolver_cgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_cgesv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgesv_batched_full_rank,&
      rocsolver_cgesv_batched_rank_0,&
      rocsolver_cgesv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgesv_batched
    function rocsolver_zgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_zgesv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgesv_batched_full_rank,&
      rocsolver_zgesv_batched_rank_0,&
      rocsolver_zgesv_batched_rank_1
#endif
  end interface
  !>     \brief GESV_STRIDED_BATCHED solves a batch of general systems of n linear equations
  !>     on n variables.
  !> 
  !>     \details
  !>     The linear systems are of the form
  !> 
  !>     \f[
  !>         A_j X_j = B_j
  !>     \f]
  !> 
  !>     where \f$A_j\f$ is a general n-by-n matrix. Matrix \f$A_j\f$ is first factorized in triangular factors \f$L_j\f$ and \f$U_j\f$
  !>     using \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED"; then, the solutions are computed with \ref rocsolver_sgetrs_strided_batched "GETRS_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the matrices A_j.
  !>                 On exit, if info_j = 0, the factors L_j and U_j of the LU decomposition of A_j returned by
  !>                 \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     ipiv        pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>                 The vectors ipiv_j of pivot indices returned by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     strideP     rocblas_stride.\n
  !>                 Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>                 There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU (size depends on the value of strideB).\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[in]
  !>     strideB     rocblas_stride.\n
  !>                 Stride from the start of one matrix B_j to the next one B_(j+1).
  !>                 There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for A_j.
  !>                 If info[i] = j > 0, U_i is singular, and the solution could not be computed.
  !>                 U_j[i,i] is the first zero element in the diagonal.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_sgesv_strided_batched
    function rocsolver_sgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_sgesv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgesv_strided_batched_full_rank,&
      rocsolver_sgesv_strided_batched_rank_0,&
      rocsolver_sgesv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgesv_strided_batched
    function rocsolver_dgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_dgesv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgesv_strided_batched_full_rank,&
      rocsolver_dgesv_strided_batched_rank_0,&
      rocsolver_dgesv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgesv_strided_batched
    function rocsolver_cgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_cgesv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgesv_strided_batched_full_rank,&
      rocsolver_cgesv_strided_batched_rank_0,&
      rocsolver_cgesv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgesv_strided_batched
    function rocsolver_zgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_zgesv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgesv_strided_batched_full_rank,&
      rocsolver_zgesv_strided_batched_rank_0,&
      rocsolver_zgesv_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRI inverts a general n-by-n matrix A using the LU factorization
  !>     computed by \ref rocsolver_sgetrf "GETRF".
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         A^{-1}L = U^{-1}
  !>     \f]
  !> 
  !>     where L is the lower triangular factor of A with unit diagonal elements, and U is the
  !>     upper triangular factor.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the factors L and U of the factorization A = P*L*U returned by \ref rocsolver_sgetrf "GETRF".
  !>               On exit, the inverse of A if info = 0; otherwise undefined.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The pivot indices returned by \ref rocsolver_sgetrf "GETRF".
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, U is singular. U[i,i] is the first zero pivot.
  !>
  interface rocsolver_sgetri
    function rocsolver_sgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_full_rank,&
      rocsolver_sgetri_rank_0,&
      rocsolver_sgetri_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri
    function rocsolver_dgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_full_rank,&
      rocsolver_dgetri_rank_0,&
      rocsolver_dgetri_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri
    function rocsolver_cgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_full_rank,&
      rocsolver_cgetri_rank_0,&
      rocsolver_cgetri_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri
    function rocsolver_zgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_full_rank,&
      rocsolver_zgetri_rank_0,&
      rocsolver_zgetri_rank_1
#endif
  end interface
  !>     \brief GETRI_BATCHED inverts a batch of general n-by-n matrices using
  !>     the LU factorization computed by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !> 
  !>     \details
  !>     The inverse of matrix \f$A_j\f$ in the batch is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j^{-1} L_j = U_j^{-1}
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is the lower triangular factor of \f$A_j\f$ with unit diagonal elements, and \f$U_j\f$ is the
  !>     upper triangular factor.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the factors L_j and U_j of the factorization A = P_j*L_j*U_j returned by
  !>               \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>               On exit, the inverses of A_j if info[j] = 0; otherwise undefined.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               The pivot indices returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(i+j).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_batched
    function rocsolver_sgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_sgetri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_batched_full_rank,&
      rocsolver_sgetri_batched_rank_0,&
      rocsolver_sgetri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_batched
    function rocsolver_dgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dgetri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_batched_full_rank,&
      rocsolver_dgetri_batched_rank_0,&
      rocsolver_dgetri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_batched
    function rocsolver_cgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_cgetri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_batched_full_rank,&
      rocsolver_cgetri_batched_rank_0,&
      rocsolver_cgetri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_batched
    function rocsolver_zgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zgetri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_batched_full_rank,&
      rocsolver_zgetri_batched_rank_0,&
      rocsolver_zgetri_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_STRIDED_BATCHED inverts a batch of general n-by-n matrices
  !>     using the LU factorization computed by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !> 
  !>     \details
  !>     The inverse of matrix \f$A_j\f$ in the batch is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j^{-1} L_j = U_j^{-1}
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is the lower triangular factor of \f$A_j\f$ with unit diagonal elements, and \f$U_j\f$ is the
  !>     upper triangular factor.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the factors L_j and U_j of the factorization A_j = P_j*L_j*U_j returned by
  !>               \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>               On exit, the inverses of A_j if info[j] = 0; otherwise undefined.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[in]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               The pivot indices returned by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_strided_batched
    function rocsolver_sgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_sgetri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_strided_batched_full_rank,&
      rocsolver_sgetri_strided_batched_rank_0,&
      rocsolver_sgetri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_strided_batched
    function rocsolver_dgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dgetri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_strided_batched_full_rank,&
      rocsolver_dgetri_strided_batched_rank_0,&
      rocsolver_dgetri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_strided_batched
    function rocsolver_cgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_cgetri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_strided_batched_full_rank,&
      rocsolver_cgetri_strided_batched_rank_0,&
      rocsolver_cgetri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_strided_batched
    function rocsolver_zgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zgetri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_strided_batched_full_rank,&
      rocsolver_zgetri_strided_batched_rank_0,&
      rocsolver_zgetri_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_NPVT inverts a general n-by-n matrix A using the LU factorization
  !>     computed by \ref rocsolver_sgetrf_npvt "GETRF_NPVT".
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         A^{-1}L = U^{-1}
  !>     \f]
  !> 
  !>     where L is the lower triangular factor of A with unit diagonal elements, and U is the
  !>     upper triangular factor.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the factors L and U of the factorization A = L*U returned by \ref rocsolver_sgetrf_npvt "GETRF_NPVT".
  !>               On exit, the inverse of A if info = 0; otherwise undefined.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, U is singular. U[i,i] is the first zero pivot.
  !>
  interface rocsolver_sgetri_npvt
    function rocsolver_sgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_sgetri_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_npvt_full_rank,&
      rocsolver_sgetri_npvt_rank_0,&
      rocsolver_sgetri_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_npvt
    function rocsolver_dgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_dgetri_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_npvt_full_rank,&
      rocsolver_dgetri_npvt_rank_0,&
      rocsolver_dgetri_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_npvt
    function rocsolver_cgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_cgetri_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_npvt_full_rank,&
      rocsolver_cgetri_npvt_rank_0,&
      rocsolver_cgetri_npvt_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_npvt
    function rocsolver_zgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_zgetri_npvt")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_npvt_full_rank,&
      rocsolver_zgetri_npvt_rank_0,&
      rocsolver_zgetri_npvt_rank_1
#endif
  end interface
  !>     \brief GETRI_NPVT_BATCHED inverts a batch of general n-by-n matrices using
  !>     the LU factorization computed by \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED".
  !> 
  !>     \details
  !>     The inverse of matrix \f$A_j\f$ in the batch is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j^{-1} L_j = U_j^{-1}
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is the lower triangular factor of \f$A_j\f$ with unit diagonal elements, and \f$U_j\f$ is the
  !>     upper triangular factor.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the factors L_j and U_j of the factorization A = L_j*U_j returned by
  !>               \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED".
  !>               On exit, the inverses of A_j if info[j] = 0; otherwise undefined.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_npvt_batched
    function rocsolver_sgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_sgetri_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_npvt_batched_full_rank,&
      rocsolver_sgetri_npvt_batched_rank_0,&
      rocsolver_sgetri_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_npvt_batched
    function rocsolver_dgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dgetri_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_npvt_batched_full_rank,&
      rocsolver_dgetri_npvt_batched_rank_0,&
      rocsolver_dgetri_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_npvt_batched
    function rocsolver_cgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_cgetri_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_npvt_batched_full_rank,&
      rocsolver_cgetri_npvt_batched_rank_0,&
      rocsolver_cgetri_npvt_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_npvt_batched
    function rocsolver_zgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_zgetri_npvt_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_npvt_batched_full_rank,&
      rocsolver_zgetri_npvt_batched_rank_0,&
      rocsolver_zgetri_npvt_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_NPVT_STRIDED_BATCHED inverts a batch of general n-by-n matrices
  !>     using the LU factorization computed by \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED".
  !> 
  !>     \details
  !>     The inverse of matrix \f$A_j\f$ in the batch is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j^{-1} L_j = U_j^{-1}
  !>     \f]
  !> 
  !>     where \f$L_j\f$ is the lower triangular factor of \f$A_j\f$ with unit diagonal elements, and \f$U_j\f$ is the
  !>     upper triangular factor.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the factors L_j and U_j of the factorization A_j = L_j*U_j returned by
  !>               \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED".
  !>               On exit, the inverses of A_j if info[j] = 0; otherwise undefined.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_npvt_strided_batched
    function rocsolver_sgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_sgetri_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_npvt_strided_batched_full_rank,&
      rocsolver_sgetri_npvt_strided_batched_rank_0,&
      rocsolver_sgetri_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_npvt_strided_batched
    function rocsolver_dgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dgetri_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_npvt_strided_batched_full_rank,&
      rocsolver_dgetri_npvt_strided_batched_rank_0,&
      rocsolver_dgetri_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_npvt_strided_batched
    function rocsolver_cgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_cgetri_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_npvt_strided_batched_full_rank,&
      rocsolver_cgetri_npvt_strided_batched_rank_0,&
      rocsolver_cgetri_npvt_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_npvt_strided_batched
    function rocsolver_zgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_zgetri_npvt_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_npvt_strided_batched_full_rank,&
      rocsolver_zgetri_npvt_strided_batched_rank_0,&
      rocsolver_zgetri_npvt_strided_batched_rank_1
#endif
  end interface
  !>     \brief GELS solves an overdetermined (or underdetermined) linear system defined by an m-by-n
  !>     matrix A, and a corresponding matrix B, using the QR factorization computed by \ref rocsolver_sgeqrf "GEQRF" (or the LQ
  !>     factorization computed by \ref rocsolver_sgelqf "GELQF").
  !> 
  !>     \details
  !>     Depending on the value of trans, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = B & \: \text{not transposed, or}\newline
  !>
  !>         A' X = B & \: \text{transposed if real, or conjugate transposed if complex}
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined
  !>     and a least-squares solution approximating X is found by minimizing
  !> 
  !>     \f[
  !>         || B - A  X || \quad \text{(or} \: || B - A' X ||\text{)}
  !>     \f]
  !> 
  !>     If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined
  !>     and a unique solution for X is chosen such that \f$|| X ||\f$ is minimal.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     trans     rocblas_operation.\n
  !>               Specifies the form of the system of equations.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of matrix A.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of matrix A.
  !>     @param[in]
  !>     nrhs      rocblas_int. nrhs >= 0.\n
  !>               The number of columns of matrices B and X;
  !>               i.e., the columns on the right hand side.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A.
  !>               On exit, the QR (or LQ) factorization of A as returned by \ref rocsolver_sgeqrf "GEQRF" (or \ref rocsolver_sgelqf "GELQF").
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrix A.
  !>     @param[inout]
  !>     B         pointer to type. Array on the GPU of dimension ldb*nrhs.\n
  !>               On entry, the matrix B.
  !>               On exit, when info = 0, B is overwritten by the solution vectors (and the residuals in
  !>               the overdetermined cases) stored as columns.
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= max(m,n).\n
  !>               Specifies the leading dimension of matrix B.
  !>     @param[out]
  !>     info      pointer to rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j > 0, the solution could not be computed because input matrix A is
  !>               rank deficient; the j-th diagonal element of its triangular factor is zero.
  !>
  interface rocsolver_sgels
    function rocsolver_sgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_sgels")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgels_full_rank,&
      rocsolver_sgels_rank_0,&
      rocsolver_sgels_rank_1
#endif
  end interface
  
  interface rocsolver_dgels
    function rocsolver_dgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_dgels")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgels_full_rank,&
      rocsolver_dgels_rank_0,&
      rocsolver_dgels_rank_1
#endif
  end interface
  
  interface rocsolver_cgels
    function rocsolver_cgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_cgels")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgels_full_rank,&
      rocsolver_cgels_rank_0,&
      rocsolver_cgels_rank_1
#endif
  end interface
  
  interface rocsolver_zgels
    function rocsolver_zgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_zgels")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgels_full_rank,&
      rocsolver_zgels_rank_0,&
      rocsolver_zgels_rank_1
#endif
  end interface
  !>     \brief GELS_BATCHED solves a batch of overdetermined (or underdetermined) linear systems
  !>     defined by a set of m-by-n matrices \f$A_i\f$, and corresponding matrices \f$B_i\f$, using the
  !>     QR factorizations computed by \ref rocsolver_sgeqrf_batched "GEQRF_BATCHED" (or the LQ factorizations computed by \ref rocsolver_sgelqf_batched "GELQF_BATCHED").
  !> 
  !>     \details
  !>     For each instance in the batch, depending on the value of trans, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = B_i & \: \text{not transposed, or}\newline
  !>
  !>         A_i' X_i = B_i & \: \text{transposed if real, or conjugate transposed if complex}
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined
  !>     and a least-squares solution approximating X_i is found by minimizing
  !> 
  !>     \f[
  !>         || B_i - A_i  X_i || \quad \text{(or} \: || B_i - A_i' X_i ||\text{)}
  !>     \f]
  !> 
  !>     If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined
  !>     and a unique solution for X_i is chosen such that \f$|| X_i ||\f$ is minimal.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     trans     rocblas_operation.\n
  !>               Specifies the form of the system of equations.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[in]
  !>     nrhs      rocblas_int. nrhs >= 0.\n
  !>               The number of columns of all matrices B_i and X_i in the batch;
  !>               i.e., the columns on the right hand side.
  !>     @param[inout]
  !>     A         array of pointer to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i.
  !>               On exit, the QR (or LQ) factorizations of A_i as returned by \ref rocsolver_sgeqrf_batched "GEQRF_BATCHED" (or \ref rocsolver_sgelqf_batched "GELQF_BATCHED").
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[inout]
  !>     B         array of pointer to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.\n
  !>               On entry, the matrices B_i.
  !>               On exit, when info[i] = 0, B_i is overwritten by the solution vectors (and the residuals in
  !>               the overdetermined cases) stored as columns.
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= max(m,n).\n
  !>               Specifies the leading dimension of matrices B_i.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for solution of A_i.
  !>               If info[i] = j > 0, the solution of A_i could not be computed because input
  !>               matrix A_i is rank deficient; the j-th diagonal element of its triangular factor is zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>               Number of matrices in the batch.
  !>
  interface rocsolver_sgels_batched
    function rocsolver_sgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_sgels_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgels_batched_full_rank,&
      rocsolver_sgels_batched_rank_0,&
      rocsolver_sgels_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgels_batched
    function rocsolver_dgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_dgels_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgels_batched_full_rank,&
      rocsolver_dgels_batched_rank_0,&
      rocsolver_dgels_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgels_batched
    function rocsolver_cgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_cgels_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgels_batched_full_rank,&
      rocsolver_cgels_batched_rank_0,&
      rocsolver_cgels_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgels_batched
    function rocsolver_zgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_zgels_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgels_batched_full_rank,&
      rocsolver_zgels_batched_rank_0,&
      rocsolver_zgels_batched_rank_1
#endif
  end interface
  !>     \brief GELS_STRIDED_BATCHED solves a batch of overdetermined (or underdetermined) linear
  !>     systems defined by a set of m-by-n matrices \f$A_i\f$, and corresponding matrices \f$B_i\f$,
  !>     using the QR factorizations computed by \ref rocsolver_sgeqrf_strided_batched "GEQRF_STRIDED_BATCHED"
  !>     (or the LQ factorizations computed by \ref rocsolver_sgelqf_strided_batched "GELQF_STRIDED_BATCHED").
  !> 
  !>     \details
  !>     For each instance in the batch, depending on the value of trans, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = B_i & \: \text{not transposed, or}\newline
  !>
  !>         A_i' X_i = B_i & \: \text{transposed if real, or conjugate transposed if complex}
  !>         \end{array}
  !>     \f]
  !> 
  !>     If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined
  !>     and a least-squares solution approximating X_i is found by minimizing
  !> 
  !>     \f[
  !>         || B_i - A_i  X_i || \quad \text{(or} \: || B_i - A_i' X_i ||\text{)}
  !>     \f]
  !> 
  !>     If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined
  !>     and a unique solution for X_i is chosen such that \f$|| X_i ||\f$ is minimal.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     trans     rocblas_operation.\n
  !>               Specifies the form of the system of equations.
  !>     @param[in]
  !>     m         rocblas_int. m >= 0.\n
  !>               The number of rows of all matrices A_i in the batch.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of columns of all matrices A_i in the batch.
  !>     @param[in]
  !>     nrhs      rocblas_int. nrhs >= 0.\n
  !>               The number of columns of all matrices B_i and X_i in the batch;
  !>               i.e., the columns on the right hand side.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i.
  !>               On exit, the QR (or LQ) factorizations of A_i as returned by \ref rocsolver_sgeqrf_strided_batched "GEQRF_STRIDED_BATCHED"
  !>               (or \ref rocsolver_sgelqf_strided_batched "GELQF_STRIDED_BATCHED").
  !>     @param[in]
  !>     lda       rocblas_int. lda >= m.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[inout]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               On entry, the matrices B_i.
  !>               On exit, when info = 0, each B_i is overwritten by the solution vectors (and the residuals in
  !>               the overdetermined cases) stored as columns.
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= max(m,n).\n
  !>               Specifies the leading dimension of matrices B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for solution of A_i.
  !>               If info[i] = j > 0, the solution of A_i could not be computed because input
  !>               matrix A_i is rank deficient; the j-th diagonal element of its triangular factor is zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>               Number of matrices in the batch.
  !>
  interface rocsolver_sgels_strided_batched
    function rocsolver_sgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_sgels_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgels_strided_batched_full_rank,&
      rocsolver_sgels_strided_batched_rank_0,&
      rocsolver_sgels_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgels_strided_batched
    function rocsolver_dgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_dgels_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgels_strided_batched_full_rank,&
      rocsolver_dgels_strided_batched_rank_0,&
      rocsolver_dgels_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgels_strided_batched
    function rocsolver_cgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_cgels_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgels_strided_batched_full_rank,&
      rocsolver_cgels_strided_batched_rank_0,&
      rocsolver_cgels_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgels_strided_batched
    function rocsolver_zgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_zgels_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_operation_none)),value :: trans
      integer(c_int),value :: m
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgels_strided_batched_full_rank,&
      rocsolver_zgels_strided_batched_rank_0,&
      rocsolver_zgels_strided_batched_rank_1
#endif
  end interface
  !>     \brief POTF2 computes the Cholesky factorization of a real symmetric (complex
  !>     Hermitian) positive definite matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A = U'U & \: \text{if uplo is upper, or}\newline
  !>
  !>         A = LL' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     U is an upper triangular matrix and L is lower triangular.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A to be factored. On exit, the lower or upper triangular factor.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful factorization of matrix A.
  !>               If info = j > 0, the leading minor of order j of A is not positive definite.
  !>               The factorization stopped at this point.
  interface rocsolver_spotf2
    function rocsolver_spotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotf2_full_rank,&
      rocsolver_spotf2_rank_0,&
      rocsolver_spotf2_rank_1
#endif
  end interface
  
  interface rocsolver_dpotf2
    function rocsolver_dpotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotf2_full_rank,&
      rocsolver_dpotf2_rank_0,&
      rocsolver_dpotf2_rank_1
#endif
  end interface
  
  interface rocsolver_cpotf2
    function rocsolver_cpotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotf2_full_rank,&
      rocsolver_cpotf2_rank_0,&
      rocsolver_cpotf2_rank_1
#endif
  end interface
  
  interface rocsolver_zpotf2
    function rocsolver_zpotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotf2_full_rank,&
      rocsolver_zpotf2_rank_0,&
      rocsolver_zpotf2_rank_1
#endif
  end interface
  !>     \brief POTF2_BATCHED computes the Cholesky factorization of a
  !>     batch of real symmetric (complex Hermitian) positive definite matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i'U_i & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_i = L_iL_i' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     \f$U_i\f$ is an upper triangular matrix and \f$L_i\f$ is lower triangular.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A_i.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i to be factored. On exit, the upper or lower triangular factors.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A_i.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful factorization of matrix A_i.
  !>               If info[i] = j > 0, the leading minor of order j of A_i is not positive definite.
  !>               The i-th factorization stopped at this point.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_spotf2_batched
    function rocsolver_spotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_spotf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotf2_batched_full_rank,&
      rocsolver_spotf2_batched_rank_0,&
      rocsolver_spotf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotf2_batched
    function rocsolver_dpotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dpotf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotf2_batched_full_rank,&
      rocsolver_dpotf2_batched_rank_0,&
      rocsolver_dpotf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotf2_batched
    function rocsolver_cpotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_cpotf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotf2_batched_full_rank,&
      rocsolver_cpotf2_batched_rank_0,&
      rocsolver_cpotf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotf2_batched
    function rocsolver_zpotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_zpotf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotf2_batched_full_rank,&
      rocsolver_zpotf2_batched_rank_0,&
      rocsolver_zpotf2_batched_rank_1
#endif
  end interface
  !>     \brief POTF2_STRIDED_BATCHED computes the Cholesky factorization of a
  !>     batch of real symmetric (complex Hermitian) positive definite matrices.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i'U_i & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_i = L_iL_i' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     \f$U_i\f$ is an upper triangular matrix and \f$L_i\f$ is lower triangular.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A_i.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i to be factored. On exit, the upper or lower triangular factors.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful factorization of matrix A_i.
  !>               If info[i] = j > 0, the leading minor of order j of A_i is not positive definite.
  !>               The i-th factorization stopped at this point.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_spotf2_strided_batched
    function rocsolver_spotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_spotf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotf2_strided_batched_full_rank,&
      rocsolver_spotf2_strided_batched_rank_0,&
      rocsolver_spotf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotf2_strided_batched
    function rocsolver_dpotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dpotf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotf2_strided_batched_full_rank,&
      rocsolver_dpotf2_strided_batched_rank_0,&
      rocsolver_dpotf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotf2_strided_batched
    function rocsolver_cpotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_cpotf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotf2_strided_batched_full_rank,&
      rocsolver_cpotf2_strided_batched_rank_0,&
      rocsolver_cpotf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotf2_strided_batched
    function rocsolver_zpotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_zpotf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotf2_strided_batched_full_rank,&
      rocsolver_zpotf2_strided_batched_rank_0,&
      rocsolver_zpotf2_strided_batched_rank_1
#endif
  end interface
  !>     \brief POTRF computes the Cholesky factorization of a real symmetric (complex
  !>     Hermitian) positive definite matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A = U'U & \: \text{if uplo is upper, or}\newline
  !>
  !>         A = LL' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     U is an upper triangular matrix and L is lower triangular.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A to be factored. On exit, the lower or upper triangular factor.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful factorization of matrix A.
  !>               If info = j > 0, the leading minor of order j of A is not positive definite.
  !>               The factorization stopped at this point.
  interface rocsolver_spotrf
    function rocsolver_spotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotrf_full_rank,&
      rocsolver_spotrf_rank_0,&
      rocsolver_spotrf_rank_1
#endif
  end interface
  
  interface rocsolver_dpotrf
    function rocsolver_dpotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotrf_full_rank,&
      rocsolver_dpotrf_rank_0,&
      rocsolver_dpotrf_rank_1
#endif
  end interface
  
  interface rocsolver_cpotrf
    function rocsolver_cpotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotrf_full_rank,&
      rocsolver_cpotrf_rank_0,&
      rocsolver_cpotrf_rank_1
#endif
  end interface
  
  interface rocsolver_zpotrf
    function rocsolver_zpotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotrf_full_rank,&
      rocsolver_zpotrf_rank_0,&
      rocsolver_zpotrf_rank_1
#endif
  end interface
  !>     \brief POTRF_BATCHED computes the Cholesky factorization of a
  !>     batch of real symmetric (complex Hermitian) positive definite matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i'U_i & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_i = L_iL_i' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     \f$U_i\f$ is an upper triangular matrix and \f$L_i\f$ is lower triangular.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A_i.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i to be factored. On exit, the upper or lower triangular factors.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A_i.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful factorization of matrix A_i.
  !>               If info[i] = j > 0, the leading minor of order j of A_i is not positive definite.
  !>               The i-th factorization stopped at this point.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_spotrf_batched
    function rocsolver_spotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_spotrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotrf_batched_full_rank,&
      rocsolver_spotrf_batched_rank_0,&
      rocsolver_spotrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotrf_batched
    function rocsolver_dpotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dpotrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotrf_batched_full_rank,&
      rocsolver_dpotrf_batched_rank_0,&
      rocsolver_dpotrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotrf_batched
    function rocsolver_cpotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_cpotrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotrf_batched_full_rank,&
      rocsolver_cpotrf_batched_rank_0,&
      rocsolver_cpotrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotrf_batched
    function rocsolver_zpotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_zpotrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotrf_batched_full_rank,&
      rocsolver_zpotrf_batched_rank_0,&
      rocsolver_zpotrf_batched_rank_1
#endif
  end interface
  !>     \brief POTRF_STRIDED_BATCHED computes the Cholesky factorization of a
  !>     batch of real symmetric (complex Hermitian) positive definite matrices.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization of matrix \f$A_i\f$ in the batch has the form:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i'U_i & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_i = L_iL_i' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     \f$U_i\f$ is an upper triangular matrix and \f$L_i\f$ is lower triangular.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A_i.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i to be factored. On exit, the upper or lower triangular factors.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful factorization of matrix A_i.
  !>               If info[i] = j > 0, the leading minor of order j of A_i is not positive definite.
  !>               The i-th factorization stopped at this point.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_spotrf_strided_batched
    function rocsolver_spotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_spotrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotrf_strided_batched_full_rank,&
      rocsolver_spotrf_strided_batched_rank_0,&
      rocsolver_spotrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotrf_strided_batched
    function rocsolver_dpotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dpotrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotrf_strided_batched_full_rank,&
      rocsolver_dpotrf_strided_batched_rank_0,&
      rocsolver_dpotrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotrf_strided_batched
    function rocsolver_cpotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_cpotrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotrf_strided_batched_full_rank,&
      rocsolver_cpotrf_strided_batched_rank_0,&
      rocsolver_cpotrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotrf_strided_batched
    function rocsolver_zpotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_zpotrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotrf_strided_batched_full_rank,&
      rocsolver_zpotrf_strided_batched_rank_0,&
      rocsolver_zpotrf_strided_batched_rank_1
#endif
  end interface
  !>     \brief POTRS solves a symmetric/hermitian system of n linear equations on n variables in its factorized form.
  !> 
  !>     \details
  !>     It solves the system
  !> 
  !>     \f[
  !>         A X = B
  !>     \f]
  !> 
  !>     where A is a real symmetric (complex hermitian) positive definite matrix defined by its triangular factor
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A = U'U & \: \text{if uplo is upper, or}\newline
  !>
  !>         A = LL' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     as returned by \ref rocsolver_spotrf "POTRF".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the factorization is upper or lower triangular.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of A.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of the matrix B.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 The factor L or U of the Cholesky factorization of A returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of A.
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrix B.
  !>                 On exit, the solution matrix X.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of B.
  !>
  interface rocsolver_spotrs
    function rocsolver_spotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_spotrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotrs_full_rank,&
      rocsolver_spotrs_rank_0,&
      rocsolver_spotrs_rank_1
#endif
  end interface
  
  interface rocsolver_dpotrs
    function rocsolver_dpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_dpotrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotrs_full_rank,&
      rocsolver_dpotrs_rank_0,&
      rocsolver_dpotrs_rank_1
#endif
  end interface
  
  interface rocsolver_cpotrs
    function rocsolver_cpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_cpotrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotrs_full_rank,&
      rocsolver_cpotrs_rank_0,&
      rocsolver_cpotrs_rank_1
#endif
  end interface
  
  interface rocsolver_zpotrs
    function rocsolver_zpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_zpotrs")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotrs_full_rank,&
      rocsolver_zpotrs_rank_0,&
      rocsolver_zpotrs_rank_1
#endif
  end interface
  !>     \brief POTRS_BATCHED solves a batch of symmetric/hermitian systems of n linear equations on n
  !>     variables in its factorized forms.
  !> 
  !>     \details
  !>     For each instance j in the batch, it solves the system
  !> 
  !>     \f[
  !>         A_j X_j = B_j
  !>     \f]
  !> 
  !>     where \f$A_j\f$ is a real symmetric (complex hermitian) positive definite matrix defined by its
  !>     triangular factor
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_j = U_j'U_j & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_j = L_jL_j' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     as returned by \ref rocsolver_spotrf "POTRF_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the factorization is upper or lower triangular.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 The factor L_j or U_j of the Cholesky factorization of A_j returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in,out]
  !>     B           Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_spotrs_batched
    function rocsolver_spotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_spotrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotrs_batched_full_rank,&
      rocsolver_spotrs_batched_rank_0,&
      rocsolver_spotrs_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotrs_batched
    function rocsolver_dpotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_dpotrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotrs_batched_full_rank,&
      rocsolver_dpotrs_batched_rank_0,&
      rocsolver_dpotrs_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotrs_batched
    function rocsolver_cpotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_cpotrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotrs_batched_full_rank,&
      rocsolver_cpotrs_batched_rank_0,&
      rocsolver_cpotrs_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotrs_batched
    function rocsolver_zpotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_zpotrs_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotrs_batched_full_rank,&
      rocsolver_zpotrs_batched_rank_0,&
      rocsolver_zpotrs_batched_rank_1
#endif
  end interface
  !>     \brief POTRS_STRIDED_BATCHED solves a batch of symmetric/hermitian systems of n linear equations
  !>     on n variables in its factorized forms.
  !> 
  !>     \details
  !>     For each instance j in the batch, it solves the system
  !> 
  !>     \f[
  !>         A_j X_j = B_j
  !>     \f]
  !> 
  !>     where \f$A_j\f$ is a real symmetric (complex hermitian) positive definite matrix defined by its
  !>     triangular factor
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_j = U_j'U_j & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_j = L_jL_j' & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     as returned by \ref rocsolver_spotrf "POTRF_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the factorization is upper or lower triangular.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 The factor L_j or U_j of the Cholesky factorization of A_j returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU (size depends on the value of strideB).\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[in]
  !>     strideB     rocblas_stride.\n
  !>                 Stride from the start of one matrix B_j to the next one B_(j+1).
  !>                 There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_spotrs_strided_batched
    function rocsolver_spotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_spotrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotrs_strided_batched_full_rank,&
      rocsolver_spotrs_strided_batched_rank_0,&
      rocsolver_spotrs_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotrs_strided_batched
    function rocsolver_dpotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_dpotrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotrs_strided_batched_full_rank,&
      rocsolver_dpotrs_strided_batched_rank_0,&
      rocsolver_dpotrs_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotrs_strided_batched
    function rocsolver_cpotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_cpotrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotrs_strided_batched_full_rank,&
      rocsolver_cpotrs_strided_batched_rank_0,&
      rocsolver_cpotrs_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotrs_strided_batched
    function rocsolver_zpotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_zpotrs_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotrs_strided_batched_full_rank,&
      rocsolver_zpotrs_strided_batched_rank_0,&
      rocsolver_zpotrs_strided_batched_rank_1
#endif
  end interface
  !>     \brief POSV solves a symmetric/hermitian system of n linear equations on n variables.
  !> 
  !>     \details
  !>     It solves the system
  !> 
  !>     \f[
  !>         A X = B
  !>     \f]
  !> 
  !>     where A is a real symmetric (complex hermitian) positive definite matrix. Matrix A is first
  !>     factorized as \f$A=LL'\f$ or \f$A=U'U\f$, depending on the value of uplo, using \ref rocsolver_spotrf "POTRF";
  !>     then, the solution is computed with \ref rocsolver_spotrs "POTRS".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the factorization is upper or lower triangular.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of A.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of the matrix B.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the symmetric/hermitian matrix A.
  !>                 On exit, if info = 0, the factor L or U of the Cholesky factorization of A returned by
  !>                 \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of A.
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrix B.
  !>                 On exit, the solution matrix X.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of B.
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit.
  !>                 If info = j > 0, the leading minor of order j of A is not positive definite.
  !>                 The solution could not be computed.
  !>
  interface rocsolver_sposv
    function rocsolver_sposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_sposv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sposv_full_rank,&
      rocsolver_sposv_rank_0,&
      rocsolver_sposv_rank_1
#endif
  end interface
  
  interface rocsolver_dposv
    function rocsolver_dposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_dposv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dposv_full_rank,&
      rocsolver_dposv_rank_0,&
      rocsolver_dposv_rank_1
#endif
  end interface
  
  interface rocsolver_cposv
    function rocsolver_cposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_cposv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cposv_full_rank,&
      rocsolver_cposv_rank_0,&
      rocsolver_cposv_rank_1
#endif
  end interface
  
  interface rocsolver_zposv
    function rocsolver_zposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_zposv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zposv_full_rank,&
      rocsolver_zposv_rank_0,&
      rocsolver_zposv_rank_1
#endif
  end interface
  !>     \brief POSV_BATCHED solves a batch of symmetric/hermitian systems of n linear equations on n
  !>     variables.
  !> 
  !>     \details
  !>     For each instance j in the batch, it solves the system
  !> 
  !>     \f[
  !>         A_j X_j = B_j
  !>     \f]
  !> 
  !>     where \f$A_j\f$ is a real symmetric (complex hermitian) positive definite matrix. Matrix \f$A_j\f$ is first
  !>     factorized as \f$A_j=L_jL_j'\f$ or \f$A_j=U_j'U_j\f$, depending on the value of uplo, using \ref rocsolver_spotrf_batched "POTRF_BATCHED";
  !>     then, the solution is computed with \ref rocsolver_spotrs_batched "POTRS_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the factorization is upper or lower triangular.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 On entry, the symmetric/hermitian matrices A_j.
  !>                 On exit, if info[j] = 0, the factor L_j or U_j of the Cholesky factorization of A_j returned by
  !>                 \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in,out]
  !>     B           Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit.
  !>                 If info[j] = i > 0, the leading minor of order i of A_j is not positive definite.
  !>                 The j-th solution could not be computed.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_sposv_batched
    function rocsolver_sposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_sposv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sposv_batched_full_rank,&
      rocsolver_sposv_batched_rank_0,&
      rocsolver_sposv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dposv_batched
    function rocsolver_dposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_dposv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dposv_batched_full_rank,&
      rocsolver_dposv_batched_rank_0,&
      rocsolver_dposv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cposv_batched
    function rocsolver_cposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_cposv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cposv_batched_full_rank,&
      rocsolver_cposv_batched_rank_0,&
      rocsolver_cposv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zposv_batched
    function rocsolver_zposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) bind(c, name="rocsolver_zposv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zposv_batched_full_rank,&
      rocsolver_zposv_batched_rank_0,&
      rocsolver_zposv_batched_rank_1
#endif
  end interface
  !>     \brief POSV_STRIDED_BATCHED solves a batch of symmetric/hermitian systems of n linear equations
  !>     on n variables.
  !> 
  !>     \details
  !>     For each instance j in the batch, it solves the system
  !> 
  !>     \f[
  !>         A_j X_j = B_j
  !>     \f]
  !> 
  !>     where \f$A_j\f$ is a real symmetric (complex hermitian) positive definite matrix. Matrix \f$A_j\f$ is first
  !>     factorized as \f$A_j=L_jL_j'\f$ or \f$A_j=U_j'U_j\f$, depending on the value of uplo, using \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED";
  !>     then, the solution is computed with \ref rocsolver_spotrs_strided_batched "POTRS_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the factorization is upper or lower triangular.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The order of the system, i.e. the number of columns and rows of all A_j matrices.
  !>     @param[in]
  !>     nrhs        rocblas_int. nrhs >= 0.\n
  !>                 The number of right hand sides, i.e., the number of columns
  !>                 of all the matrices B_j.
  !>     @param[in]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the symmetric/hermitian matrices A_j.
  !>                 On exit, if info[j] = 0, the factor L_j or U_j of the Cholesky factorization of A_j returned by
  !>                 \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 The leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[in,out]
  !>     B           pointer to type. Array on the GPU (size depends on the value of strideB).\n
  !>                 On entry, the right hand side matrices B_j.
  !>                 On exit, the solution matrix X_j of each system in the batch.
  !>     @param[in]
  !>     ldb         rocblas_int. ldb >= n.\n
  !>                 The leading dimension of matrices B_j.
  !>     @param[in]
  !>     strideB     rocblas_stride.\n
  !>                 Stride from the start of one matrix B_j to the next one B_(j+1).
  !>                 There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit.
  !>                 If info[j] = i > 0, the leading minor of order i of A_j is not positive definite.
  !>                 The j-th solution could not be computed.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of instances (systems) in the batch.
  !>
  interface rocsolver_sposv_strided_batched
    function rocsolver_sposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_sposv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sposv_strided_batched_full_rank,&
      rocsolver_sposv_strided_batched_rank_0,&
      rocsolver_sposv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dposv_strided_batched
    function rocsolver_dposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_dposv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dposv_strided_batched_full_rank,&
      rocsolver_dposv_strided_batched_rank_0,&
      rocsolver_dposv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cposv_strided_batched
    function rocsolver_cposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_cposv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cposv_strided_batched_full_rank,&
      rocsolver_cposv_strided_batched_rank_0,&
      rocsolver_cposv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zposv_strided_batched
    function rocsolver_zposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count) bind(c, name="rocsolver_zposv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      integer(c_int),value :: nrhs
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zposv_strided_batched_full_rank,&
      rocsolver_zposv_strided_batched_rank_0,&
      rocsolver_zposv_strided_batched_rank_1
#endif
  end interface
  !>     \brief POTRI inverts a symmetric/hermitian positive definite matrix A.
  !> 
  !>     \details
  !>     The inverse of matrix \f$A\f$ is computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A^{-1} = U^{-1} {U^{-1}}' & \: \text{if uplo is upper, or}\newline
  !>
  !>         A^{-1} = {L^{-1}}' L^{-1} & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U\f$ or \f$L\f$ is the triangular factor of the Cholesky factorization of \f$A\f$ returned by
  !>     \ref rocsolver_spotrf "POTRF".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the factor L or U of the Cholesky factorization of A returned by
  !>               \ref rocsolver_spotrf "POTRF".
  !>               On exit, the inverses of A if info = 0.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit for inversion of A.
  !>               If info = j > 0, A is singular. L[j,j] or U[j,j] is zero.
  interface rocsolver_spotri
    function rocsolver_spotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotri_full_rank,&
      rocsolver_spotri_rank_0,&
      rocsolver_spotri_rank_1
#endif
  end interface
  
  interface rocsolver_dpotri
    function rocsolver_dpotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotri_full_rank,&
      rocsolver_dpotri_rank_0,&
      rocsolver_dpotri_rank_1
#endif
  end interface
  
  interface rocsolver_cpotri
    function rocsolver_cpotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotri_full_rank,&
      rocsolver_cpotri_rank_0,&
      rocsolver_cpotri_rank_1
#endif
  end interface
  
  interface rocsolver_zpotri
    function rocsolver_zpotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotri_full_rank,&
      rocsolver_zpotri_rank_0,&
      rocsolver_zpotri_rank_1
#endif
  end interface
  !>     \brief POTRI_BATCHED inverts a batch of symmetric/hermitian positive definite matrices \f$A_i\f$.
  !> 
  !>     \details
  !>     The inverse of matrix \f$A_i\f$ in the batch is computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i^{-1} = U_i^{-1} {U_i^{-1}}' & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_i^{-1} = {L_i^{-1}}' L_i^{-1} & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U_i\f$ or \f$L_i\f$ is the triangular factor of the Cholesky factorization of \f$A_i\f$ returned by
  !>     \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A_i.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the factor L_i or U_i of the Cholesky factorization of A_i returned by
  !>               \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>               On exit, the inverses of A_i if info[i] = 0.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A_i.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for inversion of A_i.
  !>               If info[i] = j > 0, A_i is singular. L_i[j,j] or U_i[j,j] is zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_spotri_batched
    function rocsolver_spotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_spotri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotri_batched_full_rank,&
      rocsolver_spotri_batched_rank_0,&
      rocsolver_spotri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotri_batched
    function rocsolver_dpotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dpotri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotri_batched_full_rank,&
      rocsolver_dpotri_batched_rank_0,&
      rocsolver_dpotri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotri_batched
    function rocsolver_cpotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_cpotri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotri_batched_full_rank,&
      rocsolver_cpotri_batched_rank_0,&
      rocsolver_cpotri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotri_batched
    function rocsolver_zpotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_zpotri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotri_batched_full_rank,&
      rocsolver_zpotri_batched_rank_0,&
      rocsolver_zpotri_batched_rank_1
#endif
  end interface
  !>     \brief POTRI_STRIDED_BATCHED inverts a batch of symmetric/hermitian positive definite matrices \f$A_i\f$.
  !> 
  !>     \details
  !>     The inverse of matrix \f$A_i\f$ in the batch is computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i^{-1} = U_i^{-1} {U_i^{-1}}' & \: \text{if uplo is upper, or}\newline
  !>
  !>         A_i^{-1} = {L_i^{-1}}' L_i^{-1} & \: \text{if uplo is lower.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U_i\f$ or \f$L_i\f$ is the triangular factor of the Cholesky factorization of \f$A_i\f$ returned by
  !>     \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the factorization is upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of matrix A_i.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the factor L_i or U_i of the Cholesky factorization of A_i returned by
  !>               \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>               On exit, the inverses of A_i if info[i] = 0.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for inversion of A_i.
  !>               If info[i] = j > 0, A_i is singular. L_i[j,j] or U_i[j,j] is zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_spotri_strided_batched
    function rocsolver_spotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_spotri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_spotri_strided_batched_full_rank,&
      rocsolver_spotri_strided_batched_rank_0,&
      rocsolver_spotri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dpotri_strided_batched
    function rocsolver_dpotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dpotri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dpotri_strided_batched_full_rank,&
      rocsolver_dpotri_strided_batched_rank_0,&
      rocsolver_dpotri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cpotri_strided_batched
    function rocsolver_cpotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_cpotri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cpotri_strided_batched_full_rank,&
      rocsolver_cpotri_strided_batched_rank_0,&
      rocsolver_cpotri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zpotri_strided_batched
    function rocsolver_zpotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_zpotri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zpotri_strided_batched_full_rank,&
      rocsolver_zpotri_strided_batched_rank_0,&
      rocsolver_zpotri_strided_batched_rank_1
#endif
  end interface
  !>     \brief GESVD computes the singular values and optionally the singular
  !>     vectors of a general m-by-n matrix A (Singular Value Decomposition).
  !> 
  !>     \details
  !>     The SVD of matrix A is given by:
  !> 
  !>     \f[
  !>         A = U  S  V'
  !>     \f]
  !> 
  !>     where the m-by-n matrix S is zero except, possibly, for its min(m,n)
  !>     diagonal elements, which are the singular values of A. U and V are orthogonal
  !>     (unitary) matrices. The first min(m,n) columns of U and V are the left and
  !>     right singular vectors of A, respectively.
  !> 
  !>     The computation of the singular vectors is optional and it is controlled by
  !>     the function arguments left_svect and right_svect as described below. When
  !>     computed, this function returns the transpose (or transpose conjugate) of the
  !>     right singular vectors, i.e. the rows of V'.
  !> 
  !>     left_svect and right_svect are rocblas_svect enums that can take the
  !>     following values:
  !> 
  !>     - rocblas_svect_all: the entire matrix U (or V') is computed,
  !>     - rocblas_svect_singular: only the singular vectors (first min(m,n)
  !>       columns of U or rows of V') are computed,
  !>     - rocblas_svect_overwrite: the first
  !>       columns (or rows) of A are overwritten with the singular vectors, or
  !>     - rocblas_svect_none: no columns (or rows) of U (or V') are computed, i.e.
  !>       no singular vectors.
  !> 
  !>     left_svect and right_svect cannot both be set to overwrite. When neither is
  !>     set to overwrite, the contents of A are destroyed by the time the function
  !>     returns.
  !> 
  !>    \note
  !>     When m >> n (or n >> m) the algorithm could be sped up by compressing
  !>     the matrix A via a QR (or LQ) factorization, and working with the triangular
  !>     factor afterwards (thin-SVD). If the singular vectors are also requested, its
  !>     computation could be sped up as well via executing some intermediate
  !>     operations out-of-place, and relying more on matrix multiplications (GEMMs);
  !>     this will require, however, a larger memory workspace. The parameter fast_alg
  !>     controls whether the fast algorithm is executed or not. For more details, see
  !>     the "Tuning rocSOLVER performance" and "Memory model" sections of the documentation.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     left_svect  rocblas_svect.\n
  !>                 Specifies how the left singular vectors are computed.
  !>     @param[in]
  !>     right_svect rocblas_svect.\n
  !>                 Specifies how the right singular vectors are computed.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of matrix A.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of matrix A.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A.
  !>                 On exit, if left_svect (or right_svect) is equal to overwrite,
  !>                 the first columns (or rows) contain the left (or right) singular vectors;
  !>                 otherwise, the contents of A are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 The leading dimension of A.
  !>     @param[out]
  !>     S           pointer to real type. Array on the GPU of dimension min(m,n). \n
  !>                 The singular values of A in decreasing order.
  !>     @param[out]
  !>     U           pointer to type. Array on the GPU of dimension ldu*min(m,n) if
  !>                 left_svect is set to singular, or ldu*m when left_svect is equal to all.\n
  !>                 The matrix of left singular vectors stored as columns. Not
  !>                 referenced if left_svect is set to overwrite or none.
  !>     @param[in]
  !>     ldu         rocblas_int. ldu >= m if left_svect is all or singular; ldu >= 1 otherwise.\n
  !>                 The leading dimension of U.
  !>     @param[out]
  !>     V           pointer to type. Array on the GPU of dimension ldv*n. \n
  !>                 The matrix of right singular vectors stored as rows (transposed conjugate-transposed).
  !>                 Not referenced if right_svect is set to overwrite or none.
  !>     @param[in]
  !>     ldv         rocblas_int. ldv >= n if right_svect is all; ldv >= min(m,n) if right_svect is
  !>                 set to singular; or ldv >= 1 otherwise.\n The leading dimension of V.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU of dimension min(m,n)-1.\n
  !>                 This array is used to work internally with the bidiagonal matrix
  !>                 B associated with A (using \ref rocsolver_sbdsqr "BDSQR"). On exit, if info > 0, it contains the
  !>                 unconverged off-diagonal elements of B (or properly speaking, a bidiagonal
  !>                 matrix orthogonally equivalent to B). The diagonal elements of this matrix
  !>                 are in S; those that converged correspond to a subset of the singular values
  !>                 of A (not necessarily ordered).
  !>     @param[in]
  !>     fast_alg    rocblas_workmode. \n
  !>                 If set to rocblas_outofplace, the function will execute the
  !>                 fast thin-SVD version of the algorithm when possible.
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit.
  !>                 If info = i > 0, \ref rocsolver_sbdsqr "BDSQR" did not converge. i elements of E did not converge to zero.
  !>
  interface rocsolver_sgesvd
    function rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo) bind(c, name="rocsolver_sgesvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: E
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgesvd_full_rank,&
      rocsolver_sgesvd_rank_0,&
      rocsolver_sgesvd_rank_1
#endif
  end interface
  
  interface rocsolver_dgesvd
    function rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo) bind(c, name="rocsolver_dgesvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: E
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgesvd_full_rank,&
      rocsolver_dgesvd_rank_0,&
      rocsolver_dgesvd_rank_1
#endif
  end interface
  
  interface rocsolver_cgesvd
    function rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo) bind(c, name="rocsolver_cgesvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: E
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgesvd_full_rank,&
      rocsolver_cgesvd_rank_0,&
      rocsolver_cgesvd_rank_1
#endif
  end interface
  
  interface rocsolver_zgesvd
    function rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo) bind(c, name="rocsolver_zgesvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      type(c_ptr),value :: E
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgesvd_full_rank,&
      rocsolver_zgesvd_rank_0,&
      rocsolver_zgesvd_rank_1
#endif
  end interface
  !>     \brief GESVD_BATCHED computes the singular values and optionally the
  !>     singular vectors of a batch of general m-by-n matrix A (Singular Value
  !>     Decomposition).
  !> 
  !>     \details
  !>     The SVD of matrix A_j in the batch is given by:
  !> 
  !>     \f[
  !>         A_j = U_j  S_j  V_j'
  !>     \f]
  !> 
  !>     where the m-by-n matrix \f$S_j\f$ is zero except, possibly, for its min(m,n)
  !>     diagonal elements, which are the singular values of \f$A_j\f$. \f$U_j\f$ and \f$V_j\f$ are
  !>     orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_j\f$ and \f$V_j\f$ are
  !>     the left and right singular vectors of \f$A_j\f$, respectively.
  !> 
  !>     The computation of the singular vectors is optional and it is controlled by
  !>     the function arguments left_svect and right_svect as described below. When
  !>     computed, this function returns the transpose (or transpose conjugate) of the
  !>     right singular vectors, i.e. the rows of \f$V_j'\f$.
  !> 
  !>     left_svect and right_svect are rocblas_svect enums that can take the
  !>     following values:
  !> 
  !>     - rocblas_svect_all: the entire matrix \f$U_j\f$ (or \f$V_j'\f$) is computed,
  !>     - rocblas_svect_singular: only the singular vectors (first min(m,n)
  !>       columns of \f$U_j\f$ or rows of \f$V_j'\f$) are computed,
  !>     - rocblas_svect_overwrite: the
  !>       first columns (or rows) of \f$A_j\f$ are overwritten with the singular vectors, or
  !>     - rocblas_svect_none: no columns (or rows) of \f$U_j\f$ (or \f$V_j'\f$) are computed,
  !>       i.e. no singular vectors.
  !> 
  !>     left_svect and right_svect cannot both be set to overwrite. When neither is
  !>     set to overwrite, the contents of \f$A_j\f$ are destroyed by the time the function
  !>     returns.
  !> 
  !>     \note
  !>     When m >> n (or n >> m) the algorithm could be sped up by compressing
  !>     the matrix \f$A_j\f$ via a QR (or LQ) factorization, and working with the
  !>     triangular factor afterwards (thin-SVD). If the singular vectors are also
  !>     requested, its computation could be sped up as well via executing some
  !>     intermediate operations out-of-place, and relying more on matrix
  !>     multiplications (GEMMs); this will require, however, a larger memory
  !>     workspace. The parameter fast_alg controls whether the fast algorithm is
  !>     executed or not. For more details, see the "Tuning rocSOLVER performance"
  !>     and "Memory model" sections of the documentation.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     left_svect  rocblas_svect.\n
  !>                 Specifies how the left singular vectors are computed.
  !>     @param[in]
  !>     right_svect rocblas_svect.\n
  !>                 Specifies how the right singular vectors are computed.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of all matrices A_j in the batch.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A           Array of pointers to type. Each pointer points to an array on
  !>                 the GPU of dimension lda*n.\n
  !>                 On entry, the matrices A_j.
  !>                 On exit, if left_svect (or right_svect) is equal to overwrite,
  !>                 the first columns (or rows) of A_j contain the left (or right)
  !>                 corresponding singular vectors; otherwise, the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 The leading dimension of A_j.
  !>     @param[out]
  !>     S           pointer to real type. Array on the GPU (the size depends on the value of strideS).\n
  !>                 The singular values of A_j in decreasing order.
  !>     @param[in]
  !>     strideS     rocblas_stride.\n
  !>                 Stride from the start of one vector S_j to the next one S_(j+1).
  !>                 There is no restriction for the value of strideS.
  !>                 Normal use case is strideS >= min(m,n).
  !>     @param[out]
  !>     U           pointer to type. Array on the GPU (the side depends on the value of strideU). \n
  !>                 The matrices U_j of left singular vectors stored as columns.
  !>                 Not referenced if left_svect is set to overwrite or none.
  !>     @param[in]
  !>     ldu         rocblas_int. ldu >= m if left_svect is all or singular; ldu >= 1 otherwise.\n
  !>                 The leading dimension of U_j.
  !>     @param[in]
  !>     strideU     rocblas_stride.\n
  !>                 Stride from the start of one matrix U_j to the next one U_(j+1).
  !>                 There is no restriction for the value of strideU.
  !>                 Normal use case is strideU >= ldu*min(m,n) if left_svect is set to singular,
  !>                 or strideU >= ldu*m when left_svect is equal to all.
  !>     @param[out]
  !>     V           pointer to type. Array on the GPU (the size depends on the value of strideV). \n
  !>                 The matrices V_j of right singular vectors stored as rows (transposed conjugate-transposed).
  !>                 Not referenced if right_svect is set to overwrite or none.
  !>     @param[in]
  !>     ldv         rocblas_int. ldv >= n if right_svect is all; ldv >= min(m,n) if
  !>                 right_svect is set to singular; or ldv >= 1 otherwise.\n
  !>                 The leading dimension of V.
  !>     @param[in]
  !>     strideV     rocblas_stride.\n
  !>                 Stride from the start of one matrix V_j to the next one V_(j+1).
  !>                 There is no restriction for the value of strideV.
  !>                 Normal use case is strideV >= ldv*n.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the bidiagonal matrix B_j associated with A_j (using \ref rocsolver_sbdsqr "BDSQR").
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of B_j (or properly speaking,
  !>                 a bidiagonal matrix orthogonally equivalent to B_j). The diagonal elements of this matrix are in S_j;
  !>                 those that converged correspond to a subset of the singular values of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
  !>     @param[in]
  !>     fast_alg    rocblas_workmode. \n
  !>                 If set to rocblas_outofplace, the function will execute the fast thin-SVD version
  !>                 of the algorithm when possible.
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info[j] = 0, successful exit.
  !>                 If info[j] = i > 0, \ref rocsolver_sbdsqr "BDSQR" did not converge. i elements of E_j did not converge to zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgesvd_batched
    function rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_sgesvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgesvd_batched_full_rank,&
      rocsolver_sgesvd_batched_rank_0,&
      rocsolver_sgesvd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgesvd_batched
    function rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_dgesvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgesvd_batched_full_rank,&
      rocsolver_dgesvd_batched_rank_0,&
      rocsolver_dgesvd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgesvd_batched
    function rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_cgesvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgesvd_batched_full_rank,&
      rocsolver_cgesvd_batched_rank_0,&
      rocsolver_cgesvd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgesvd_batched
    function rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_zgesvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgesvd_batched_full_rank,&
      rocsolver_zgesvd_batched_rank_0,&
      rocsolver_zgesvd_batched_rank_1
#endif
  end interface
  !>     \brief GESVD_STRIDED_BATCHED computes the singular values and optionally the
  !>     singular vectors of a batch of general m-by-n matrix A (Singular Value
  !>     Decomposition).
  !> 
  !>     \details
  !>     The SVD of matrix A_j in the batch is given by:
  !> 
  !>     \f[
  !>         A_j = U_j  S_j  V_j'
  !>     \f]
  !> 
  !>     where the m-by-n matrix \f$S_j\f$ is zero except, possibly, for its min(m,n)
  !>     diagonal elements, which are the singular values of \f$A_j\f$. \f$U_j\f$ and \f$V_j\f$ are
  !>     orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_j\f$ and \f$V_j\f$ are
  !>     the left and right singular vectors of \f$A_j\f$, respectively.
  !> 
  !>     The computation of the singular vectors is optional and it is controlled by
  !>     the function arguments left_svect and right_svect as described below. When
  !>     computed, this function returns the transpose (or transpose conjugate) of the
  !>     right singular vectors, i.e. the rows of \f$V_j'\f$.
  !> 
  !>     left_svect and right_svect are rocblas_svect enums that can take the
  !>     following values:
  !> 
  !>     - rocblas_svect_all: the entire matrix \f$U_j\f$ (or \f$V_j'\f$) is computed,
  !>     - rocblas_svect_singular: only the singular vectors (first min(m,n)
  !>       columns of \f$U_j\f$ or rows of \f$V_j'\f$) are computed,
  !>     - rocblas_svect_overwrite: the
  !>       first columns (or rows) of \f$A_j\f$ are overwritten with the singular vectors, or
  !>     - rocblas_svect_none: no columns (or rows) of \f$U_j\f$ (or \f$V_j'\f$) are computed,
  !>       i.e. no singular vectors.
  !> 
  !>     left_svect and right_svect cannot both be set to overwrite. When neither is
  !>     set to overwrite, the contents of \f$A_j\f$ are destroyed by the time the function
  !>     returns.
  !> 
  !>     \note
  !>     When m >> n (or n >> m) the algorithm could be sped up by compressing
  !>     the matrix \f$A_j\f$ via a QR (or LQ) factorization, and working with the
  !>     triangular factor afterwards (thin-SVD). If the singular vectors are also
  !>     requested, its computation could be sped up as well via executing some
  !>     intermediate operations out-of-place, and relying more on matrix
  !>     multiplications (GEMMs); this will require, however, a larger memory
  !>     workspace. The parameter fast_alg controls whether the fast algorithm is
  !>     executed or not. For more details, see the "Tuning rocSOLVER performance"
  !>     and "Memory model" sections of the documentation.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     left_svect  rocblas_svect.\n
  !>                 Specifies how the left singular vectors are computed.
  !>     @param[in]
  !>     right_svect rocblas_svect.\n
  !>                 Specifies how the right singular vectors are computed.
  !>     @param[in]
  !>     m           rocblas_int. m >= 0.\n
  !>                 The number of rows of all matrices A_j in the batch.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 The number of columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the matrices A_j. On exit, if left_svect (or right_svect) is equal to
  !>                 overwrite, the first columns (or rows) of A_j contain the left (or right)
  !>                 corresponding singular vectors; otherwise, the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= m.\n
  !>                 The leading dimension of A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA.
  !>                 Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     S           pointer to real type. Array on the GPU (the size depends on the value of strideS).\n
  !>                 The singular values of A_j in decreasing order.
  !>     @param[in]
  !>     strideS     rocblas_stride.\n
  !>                 Stride from the start of one vector S_j to the next one S_(j+1).
  !>                 There is no restriction for the value of strideS.
  !>                 Normal use case is strideS >= min(m,n).
  !>     @param[out]
  !>     U           pointer to type. Array on the GPU (the side depends on the value of strideU). \n
  !>                 The matrices U_j of left singular vectors stored as columns.
  !>                 Not referenced if left_svect is set to overwrite or none.
  !>     @param[in]
  !>     ldu         rocblas_int. ldu >= m if left_svect is all or singular; ldu >= 1 otherwise.\n
  !>                 The leading dimension of U_j.
  !>     @param[in]
  !>     strideU     rocblas_stride.\n
  !>                 Stride from the start of one matrix U_j to the next one U_(j+1).
  !>                 There is no restriction for the value of strideU.
  !>                 Normal use case is strideU >= ldu*min(m,n) if left_svect is set to singular,
  !>                 or strideU >= ldu*m when left_svect is equal to all.
  !>     @param[out]
  !>     V           pointer to type. Array on the GPU (the size depends on the value of strideV). \n
  !>                 The matrices V_j of right singular vectors stored as rows (transposed conjugate-transposed).
  !>                 Not referenced if right_svect is set to overwrite or none.
  !>     @param[in]
  !>     ldv         rocblas_int. ldv >= n if right_svect is all; ldv >= min(m,n) if right_svect is
  !>                 set to singular; or ldv >= 1 otherwise.\n
  !>                 The leading dimension of V.
  !>     @param[in]
  !>     strideV     rocblas_stride.\n
  !>                 Stride from the start of one matrix V_j to the next one V_(j+1).
  !>                 There is no restriction for the value of strideV.
  !>                 Normal use case is strideV >= ldv*n.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the bidiagonal matrix B_j associated with A_j (using \ref rocsolver_sbdsqr "BDSQR").
  !>                 On exit, if info > 0, E_j contains the unconverged off-diagonal elements of B_j (or properly speaking,
  !>                 a bidiagonal matrix orthogonally equivalent to B_j). The diagonal elements of this matrix are in S_j;
  !>                 those that converged correspond to a subset of the singular values of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE.
  !>                 Normal use case is strideE >= min(m,n)-1.
  !>     @param[in]
  !>     fast_alg    rocblas_workmode. \n
  !>                 If set to rocblas_outofplace, the function will execute the fast thin-SVD version
  !>                 of the algorithm when possible.
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info[j] = 0, successful exit.
  !>                 If info[j] = i > 0, BDSQR did not converge. i elements of E_j did not converge to zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgesvd_strided_batched
    function rocsolver_sgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_sgesvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgesvd_strided_batched_full_rank,&
      rocsolver_sgesvd_strided_batched_rank_0,&
      rocsolver_sgesvd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgesvd_strided_batched
    function rocsolver_dgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_dgesvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgesvd_strided_batched_full_rank,&
      rocsolver_dgesvd_strided_batched_rank_0,&
      rocsolver_dgesvd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgesvd_strided_batched
    function rocsolver_cgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_cgesvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgesvd_strided_batched_full_rank,&
      rocsolver_cgesvd_strided_batched_rank_0,&
      rocsolver_cgesvd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgesvd_strided_batched
    function rocsolver_zgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) bind(c, name="rocsolver_zgesvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_svect_all)),value :: left_svect
      integer(kind(rocblas_svect_all)),value :: right_svect
      integer(c_int),value :: m
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: S
      integer(c_int64_t),value :: strideS
      type(c_ptr),value :: U
      integer(c_int),value :: ldu
      integer(c_int64_t),value :: strideU
      type(c_ptr),value :: V
      integer(c_int),value :: ldv
      integer(c_int64_t),value :: strideV
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(kind(rocblas_outofplace)),value :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgesvd_strided_batched_full_rank,&
      rocsolver_zgesvd_strided_batched_rank_0,&
      rocsolver_zgesvd_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYTD2 computes the tridiagonal form of a real symmetric matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The tridiagonal form is given by:
  !> 
  !>     \f[
  !>         T = Q'  A  Q
  !>     \f]
  !> 
  !>     where T is symmetric tridiagonal and Q is an orthogonal matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_{n-1} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q = H_{n-1}H_{n-2}\cdots H_1 & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{tau}[i] \cdot v_i  v_i'
  !>     \f]
  !> 
  !>     where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the symmetric matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_i stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_i stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU of dimension n.\n
  !>               The diagonal elements of T.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU of dimension n-1.\n
  !>               The off-diagonal elements of T.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU of dimension n-1.\n
  !>               The Householder scalars.
  !>
  interface rocsolver_ssytd2
    function rocsolver_ssytd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_ssytd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      real(c_float) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytd2_full_rank,&
      rocsolver_ssytd2_rank_0,&
      rocsolver_ssytd2_rank_1
#endif
  end interface
  
  interface rocsolver_dsytd2
    function rocsolver_dsytd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_dsytd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      real(c_double) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytd2_full_rank,&
      rocsolver_dsytd2_rank_0,&
      rocsolver_dsytd2_rank_1
#endif
  end interface
  !>     \brief HETD2 computes the tridiagonal form of a complex hermitian matrix A.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The tridiagonal form is given by:
  !> 
  !>     \f[
  !>         T = Q'  A  Q
  !>     \f]
  !> 
  !>     where T is hermitian tridiagonal and Q is an unitary matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_{n-1} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q = H_{n-1}H_{n-2}\cdots H_1 & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{tau}[i] \cdot v_i  v_i'
  !>     \f]
  !> 
  !>     where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the hermitian matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householders vector v_i stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_i stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               The diagonal elements of T.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension n-1.\n
  !>               The off-diagonal elements of T.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU of dimension n-1.\n
  !>               The Householder scalars.
  !>
  interface rocsolver_chetd2
    function rocsolver_chetd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_chetd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      complex(c_float_complex) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chetd2_full_rank,&
      rocsolver_chetd2_rank_0,&
      rocsolver_chetd2_rank_1
#endif
  end interface
  
  interface rocsolver_zhetd2
    function rocsolver_zhetd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_zhetd2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      complex(c_double_complex) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhetd2_full_rank,&
      rocsolver_zhetd2_rank_0,&
      rocsolver_zhetd2_rank_1
#endif
  end interface
  !>     \brief SYTD2_BATCHED computes the tridiagonal form of a batch of real symmetric matrices A_j.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is symmetric tridiagonal and \f$Q_j\f$ is an orthogonal matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the symmetric matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssytd2_batched
    function rocsolver_ssytd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_ssytd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_float) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytd2_batched_full_rank,&
      rocsolver_ssytd2_batched_rank_0,&
      rocsolver_ssytd2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytd2_batched
    function rocsolver_dsytd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_dsytd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_double) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytd2_batched_full_rank,&
      rocsolver_dsytd2_batched_rank_0,&
      rocsolver_dsytd2_batched_rank_1
#endif
  end interface
  !>     \brief HETD2_BATCHED computes the tridiagonal form of a batch of complex hermitian matrices A_j.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is Hermitian tridiagonal and \f$Q_j\f$ is a unitary matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the hermitian matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chetd2_batched
    function rocsolver_chetd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_chetd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chetd2_batched_full_rank,&
      rocsolver_chetd2_batched_rank_0,&
      rocsolver_chetd2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhetd2_batched
    function rocsolver_zhetd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_zhetd2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhetd2_batched_full_rank,&
      rocsolver_zhetd2_batched_rank_0,&
      rocsolver_zhetd2_batched_rank_1
#endif
  end interface
  !>     \brief SYTD2_STRIDED_BATCHED computes the tridiagonal form of a batch of real symmetric matrices A_j.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is symmetric tridiagonal and \f$Q_j\f$ is an orthogonal matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the symmetric matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssytd2_strided_batched
    function rocsolver_ssytd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_ssytd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_float) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytd2_strided_batched_full_rank,&
      rocsolver_ssytd2_strided_batched_rank_0,&
      rocsolver_ssytd2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytd2_strided_batched
    function rocsolver_dsytd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_dsytd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_double) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytd2_strided_batched_full_rank,&
      rocsolver_dsytd2_strided_batched_rank_0,&
      rocsolver_dsytd2_strided_batched_rank_1
#endif
  end interface
  !>     \brief HETD2_STRIDED_BATCHED computes the tridiagonal form of a batch of complex hermitian matrices A_j.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is Hermitian tridiagonal and \f$Q_j\f$ is a unitary matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the hermitian matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chetd2_strided_batched
    function rocsolver_chetd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_chetd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chetd2_strided_batched_full_rank,&
      rocsolver_chetd2_strided_batched_rank_0,&
      rocsolver_chetd2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhetd2_strided_batched
    function rocsolver_zhetd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_zhetd2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhetd2_strided_batched_full_rank,&
      rocsolver_zhetd2_strided_batched_rank_0,&
      rocsolver_zhetd2_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYTRD computes the tridiagonal form of a real symmetric matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The tridiagonal form is given by:
  !> 
  !>     \f[
  !>         T = Q'  A  Q
  !>     \f]
  !> 
  !>     where T is symmetric tridiagonal and Q is an orthogonal matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_{n-1} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q = H_{n-1}H_{n-2}\cdots H_1 & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{tau}[i] \cdot v_i  v_i'
  !>     \f]
  !> 
  !>     where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the symmetric matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_i stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_i stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU of dimension n.\n
  !>               The diagonal elements of T.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU of dimension n-1.\n
  !>               The off-diagonal elements of T.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU of dimension n-1.\n
  !>               The Householder scalars.
  !>
  interface rocsolver_ssytrd
    function rocsolver_ssytrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_ssytrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      real(c_float) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytrd_full_rank,&
      rocsolver_ssytrd_rank_0,&
      rocsolver_ssytrd_rank_1
#endif
  end interface
  
  interface rocsolver_dsytrd
    function rocsolver_dsytrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_dsytrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      real(c_double) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytrd_full_rank,&
      rocsolver_dsytrd_rank_0,&
      rocsolver_dsytrd_rank_1
#endif
  end interface
  !>     \brief HETRD computes the tridiagonal form of a complex hermitian matrix A.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The tridiagonal form is given by:
  !> 
  !>     \f[
  !>         T = Q'  A  Q
  !>     \f]
  !> 
  !>     where T is hermitian tridiagonal and Q is an unitary matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q = H_1H_2\cdots H_{n-1} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q = H_{n-1}H_{n-2}\cdots H_1 & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_i\f$ is given by
  !> 
  !>     \f[
  !>         H_i = I - \text{tau}[i] \cdot v_i  v_i'
  !>     \f]
  !> 
  !>     where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the hermitian matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_i stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_i stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               The diagonal elements of T.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension n-1.\n
  !>               The off-diagonal elements of T.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU of dimension n-1.\n
  !>               The Householder scalars.
  !>
  interface rocsolver_chetrd
    function rocsolver_chetrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_chetrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      complex(c_float_complex) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chetrd_full_rank,&
      rocsolver_chetrd_rank_0,&
      rocsolver_chetrd_rank_1
#endif
  end interface
  
  interface rocsolver_zhetrd
    function rocsolver_zhetrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_zhetrd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      complex(c_double_complex) :: tau
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhetrd_full_rank,&
      rocsolver_zhetrd_rank_0,&
      rocsolver_zhetrd_rank_1
#endif
  end interface
  !>     \brief SYTRD_BATCHED computes the tridiagonal form of a batch of real symmetric matrices A_j.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is symmetric tridiagonal and \f$Q_j\f$ is an orthogonal matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the symmetric matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssytrd_batched
    function rocsolver_ssytrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_ssytrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_float) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytrd_batched_full_rank,&
      rocsolver_ssytrd_batched_rank_0,&
      rocsolver_ssytrd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytrd_batched
    function rocsolver_dsytrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_dsytrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_double) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytrd_batched_full_rank,&
      rocsolver_dsytrd_batched_rank_0,&
      rocsolver_dsytrd_batched_rank_1
#endif
  end interface
  !>     \brief HETRD_BATCHED computes the tridiagonal form of a batch of complex hermitian matrices A_j.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is Hermitian tridiagonal and \f$Q_j\f$ is a unitary matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the hermitian matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chetrd_batched
    function rocsolver_chetrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_chetrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chetrd_batched_full_rank,&
      rocsolver_chetrd_batched_rank_0,&
      rocsolver_chetrd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhetrd_batched
    function rocsolver_zhetrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_zhetrd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhetrd_batched_full_rank,&
      rocsolver_zhetrd_batched_rank_0,&
      rocsolver_zhetrd_batched_rank_1
#endif
  end interface
  !>     \brief SYTRD_STRIDED_BATCHED computes the tridiagonal form of a batch of real symmetric matrices A_j.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is symmetric tridiagonal and \f$Q_j\f$ is an orthogonal matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the symmetric matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssytrd_strided_batched
    function rocsolver_ssytrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_ssytrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_float) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytrd_strided_batched_full_rank,&
      rocsolver_ssytrd_strided_batched_rank_0,&
      rocsolver_ssytrd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytrd_strided_batched
    function rocsolver_dsytrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_dsytrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      real(c_double) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytrd_strided_batched_full_rank,&
      rocsolver_dsytrd_strided_batched_rank_0,&
      rocsolver_dsytrd_strided_batched_rank_1
#endif
  end interface
  !>     \brief HETRD_STRIDED_BATCHED computes the tridiagonal form of a batch of complex hermitian matrices A_j.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The tridiagonal form of \f$A_j\f$ is given by:
  !> 
  !>     \f[
  !>         T_j = Q_j'  A_j  Q_j
  !>     \f]
  !> 
  !>     where \f$T_j\f$ is Hermitian tridiagonal and \f$Q_j\f$ is a unitary matrix represented as the product
  !>     of Householder matrices
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Q_j = H_{j_1}H_{j_2}\cdots H_{j_{n-1}} & \: \text{if uplo indicates lower, or}\newline
  !>
  !>         Q_j = H_{j_{n-1}}H_{j_{n-2}}\cdots H_{j_1} & \: \text{if uplo indicates upper.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     Each Householder matrix \f$H_{j_i}\f$ is given by
  !> 
  !>     \f[
  !>         H_{j_i} = I - \text{tau}_j[i] \cdot v_{j_i}  v_{j_i}'
  !>     \f]
  !> 
  !>     where \f$\text{tau}_j[i]\f$ is the corresponding Householder scalar. When uplo indicates lower, the first i
  !>     elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i+1] = 1\f$. If uplo indicates upper,
  !>     the last n-i elements of the Householder vector \f$v_{j_i}\f$ are zero, and \f$v_{j_i}[i] = 1\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the hermitian matrix A_j is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrices A_j.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_j to be factored.
  !>               On exit, if upper, then the elements on the diagonal and superdiagonal
  !>               contain the tridiagonal form T_j; the elements above the superdiagonal contain
  !>               the first i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>               If lower, then the elements on the diagonal and subdiagonal
  !>               contain the tridiagonal form T_j; the elements below the subdiagonal contain
  !>               the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               The leading dimension of A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               The diagonal elements of T_j.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_j to the next one D_(j+1).
  !>               There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               The off-diagonal elements of T_j.
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_j to the next one E_(j+1).
  !>               There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
  !>     @param[out]
  !>     tau       pointer to type. Array on the GPU (the size depends on the value of strideP).\n
  !>               Contains the vectors tau_j of corresponding Householder scalars.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector tau_j to the next one tau_(j+1).
  !>               There is no restriction for the value
  !>               of strideP. Normal use is strideP >= n-1.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chetrd_strided_batched
    function rocsolver_chetrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_chetrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chetrd_strided_batched_full_rank,&
      rocsolver_chetrd_strided_batched_rank_0,&
      rocsolver_chetrd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhetrd_strided_batched
    function rocsolver_zhetrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count) bind(c, name="rocsolver_zhetrd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t),value :: strideP
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhetrd_strided_batched_full_rank,&
      rocsolver_zhetrd_strided_batched_rank_0,&
      rocsolver_zhetrd_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYGS2 reduces a real symmetric-definite generalized eigenproblem to standard
  !>     form.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U^{-T} A U^{-1}, & \: \text{or}\newline
  !>
  !>         L^{-1} A L^{-T},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the symmetric-definite matrix B has been factorized as either \f$U^T U\f$ or \f$L L^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U A U^T, & \: \text{or}\newline
  !>
  !>         L^T A L,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored, and
  !>               whether the factorization applied to B was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A and
  !>               B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A. On exit, the transformed matrix associated with
  !>               the equivalent standard eigenvalue problem.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>
  interface rocsolver_ssygs2
    function rocsolver_ssygs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_ssygs2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygs2_full_rank,&
      rocsolver_ssygs2_rank_0,&
      rocsolver_ssygs2_rank_1
#endif
  end interface
  
  interface rocsolver_dsygs2
    function rocsolver_dsygs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_dsygs2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygs2_full_rank,&
      rocsolver_dsygs2_rank_0,&
      rocsolver_dsygs2_rank_1
#endif
  end interface
  !>     \brief HEGS2 reduces a hermitian-definite generalized eigenproblem to standard form.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U^{-H} A U^{-1}, & \: \text{or}\newline
  !>
  !>         L^{-1} A L^{-H},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the hermitian-definite matrix B has been factorized as either \f$U^H U\f$ or \f$L L^H\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U A U^H, & \: \text{or}\newline
  !>
  !>         L^H A L,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored, and
  !>               whether the factorization applied to B was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A and
  !>               B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A. On exit, the transformed matrix associated with
  !>               the equivalent standard eigenvalue problem.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>
  interface rocsolver_chegs2
    function rocsolver_chegs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_chegs2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegs2_full_rank,&
      rocsolver_chegs2_rank_0,&
      rocsolver_chegs2_rank_1
#endif
  end interface
  
  interface rocsolver_zhegs2
    function rocsolver_zhegs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_zhegs2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegs2_full_rank,&
      rocsolver_zhegs2_rank_0,&
      rocsolver_zhegs2_rank_1
#endif
  end interface
  !>     \brief SYGS2_BATCHED reduces a batch of real symmetric-definite generalized eigenproblems
  !>     to standard form.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-T} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-T},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the symmetric-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^T U_i\f$ or \f$L_i L_i^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^T, & \: \text{or}\newline
  !>
  !>         L_i^T A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssygs2_batched
    function rocsolver_ssygs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_ssygs2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygs2_batched_full_rank,&
      rocsolver_ssygs2_batched_rank_0,&
      rocsolver_ssygs2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygs2_batched
    function rocsolver_dsygs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_dsygs2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygs2_batched_full_rank,&
      rocsolver_dsygs2_batched_rank_0,&
      rocsolver_dsygs2_batched_rank_1
#endif
  end interface
  !>     \brief HEGS2_BATCHED reduces a batch of hermitian-definite generalized eigenproblems to
  !>     standard form.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-H} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-H},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the hermitian-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^H U_i\f$ or \f$L_i L_i^H\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^H, & \: \text{or}\newline
  !>
  !>         L_i^H A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chegs2_batched
    function rocsolver_chegs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_chegs2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegs2_batched_full_rank,&
      rocsolver_chegs2_batched_rank_0,&
      rocsolver_chegs2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegs2_batched
    function rocsolver_zhegs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_zhegs2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegs2_batched_full_rank,&
      rocsolver_zhegs2_batched_rank_0,&
      rocsolver_zhegs2_batched_rank_1
#endif
  end interface
  !>     \brief SYGS2_STRIDED_BATCHED reduces a batch of real symmetric-definite generalized
  !>     eigenproblems to standard form.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-T} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-T},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the symmetric-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^T U_i\f$ or \f$L_i L_i^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^T, & \: \text{or}\newline
  !>
  !>         L_i^T A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use case is strideB >= ldb*n.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssygs2_strided_batched
    function rocsolver_ssygs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_ssygs2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygs2_strided_batched_full_rank,&
      rocsolver_ssygs2_strided_batched_rank_0,&
      rocsolver_ssygs2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygs2_strided_batched
    function rocsolver_dsygs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_dsygs2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygs2_strided_batched_full_rank,&
      rocsolver_dsygs2_strided_batched_rank_0,&
      rocsolver_dsygs2_strided_batched_rank_1
#endif
  end interface
  !>     \brief HEGS2_STRIDED_BATCHED reduces a batch of hermitian-definite generalized
  !>     eigenproblems to standard form.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-H} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-H},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the hermitian-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^H U_i\f$ or \f$L_i L_i^H\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^H, & \: \text{or}\newline
  !>
  !>         L_i^H A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use case is strideB >= ldb*n.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chegs2_strided_batched
    function rocsolver_chegs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_chegs2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegs2_strided_batched_full_rank,&
      rocsolver_chegs2_strided_batched_rank_0,&
      rocsolver_chegs2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegs2_strided_batched
    function rocsolver_zhegs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_zhegs2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegs2_strided_batched_full_rank,&
      rocsolver_zhegs2_strided_batched_rank_0,&
      rocsolver_zhegs2_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYGST reduces a real symmetric-definite generalized eigenproblem to standard
  !>     form.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U^{-T} A U^{-1}, & \: \text{or}\newline
  !>
  !>         L^{-1} A L^{-T},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the symmetric-definite matrix B has been factorized as either \f$U^T U\f$ or \f$L L^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U A U^T, & \: \text{or}\newline
  !>
  !>         L^T A L,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored, and
  !>               whether the factorization applied to B was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A and
  !>               B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A. On exit, the transformed matrix associated with
  !>               the equivalent standard eigenvalue problem.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>
  interface rocsolver_ssygst
    function rocsolver_ssygst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_ssygst")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygst_full_rank,&
      rocsolver_ssygst_rank_0,&
      rocsolver_ssygst_rank_1
#endif
  end interface
  
  interface rocsolver_dsygst
    function rocsolver_dsygst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_dsygst")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygst_full_rank,&
      rocsolver_dsygst_rank_0,&
      rocsolver_dsygst_rank_1
#endif
  end interface
  !>     \brief HEGST reduces a hermitian-definite generalized eigenproblem to standard form.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U^{-H} A U^{-1}, & \: \text{or}\newline
  !>
  !>         L^{-1} A L^{-H},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the hermitian-definite matrix B has been factorized as either \f$U^H U\f$ or \f$L L^H\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U A U^H, & \: \text{or}\newline
  !>
  !>         L^H A L,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored, and
  !>               whether the factorization applied to B was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A and
  !>               B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the matrix A. On exit, the transformed matrix associated with
  !>               the equivalent standard eigenvalue problem.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>
  interface rocsolver_chegst
    function rocsolver_chegst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_chegst")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegst_full_rank,&
      rocsolver_chegst_rank_0,&
      rocsolver_chegst_rank_1
#endif
  end interface
  
  interface rocsolver_zhegst
    function rocsolver_zhegst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_zhegst")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegst_full_rank,&
      rocsolver_zhegst_rank_0,&
      rocsolver_zhegst_rank_1
#endif
  end interface
  !>     \brief SYGST_BATCHED reduces a batch of real symmetric-definite generalized eigenproblems
  !>     to standard form.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-T} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-T},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the symmetric-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^T U_i\f$ or \f$L_i L_i^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^T, & \: \text{or}\newline
  !>
  !>         L_i^T A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssygst_batched
    function rocsolver_ssygst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_ssygst_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygst_batched_full_rank,&
      rocsolver_ssygst_batched_rank_0,&
      rocsolver_ssygst_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygst_batched
    function rocsolver_dsygst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_dsygst_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygst_batched_full_rank,&
      rocsolver_dsygst_batched_rank_0,&
      rocsolver_dsygst_batched_rank_1
#endif
  end interface
  !>     \brief HEGST_BATCHED reduces a batch of hermitian-definite generalized eigenproblems to
  !>     standard form.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-H} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-H},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the hermitian-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^H U_i\f$ or \f$L_i L_i^H\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^H, & \: \text{or}\newline
  !>
  !>         L_i^H A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chegst_batched
    function rocsolver_chegst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_chegst_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegst_batched_full_rank,&
      rocsolver_chegst_batched_rank_0,&
      rocsolver_chegst_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegst_batched
    function rocsolver_zhegst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) bind(c, name="rocsolver_zhegst_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegst_batched_full_rank,&
      rocsolver_zhegst_batched_rank_0,&
      rocsolver_zhegst_batched_rank_1
#endif
  end interface
  !>     \brief SYGST_STRIDED_BATCHED reduces a batch of real symmetric-definite generalized
  !>     eigenproblems to standard form.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-T} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-T},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the symmetric-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^T U_i\f$ or \f$L_i L_i^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^T, & \: \text{or}\newline
  !>
  !>         L_i^T A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use case is strideB >= ldb*n.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_ssygst_strided_batched
    function rocsolver_ssygst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_ssygst_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygst_strided_batched_full_rank,&
      rocsolver_ssygst_strided_batched_rank_0,&
      rocsolver_ssygst_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygst_strided_batched
    function rocsolver_dsygst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_dsygst_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygst_strided_batched_full_rank,&
      rocsolver_dsygst_strided_batched_rank_0,&
      rocsolver_dsygst_strided_batched_rank_1
#endif
  end interface
  !>     \brief HEGST_STRIDED_BATCHED reduces a batch of hermitian-definite generalized
  !>     eigenproblems to standard form.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype.
  !> 
  !>     If the problem is of the 1st form, then \f$A_i\f$ is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i^{-H} A_i U_i^{-1}, & \: \text{or}\newline
  !>
  !>         L_i^{-1} A_i L_i^{-H},
  !>         \end{array}
  !>     \f]
  !> 
  !>     where the hermitian-definite matrix \f$B_i\f$ has been factorized as either \f$U_i^H U_i\f$ or \f$L_i L_i^H\f$ as returned by \ref rocsolver_spotrf "POTRF", depending
  !>     on the value of uplo.
  !> 
  !>     If the problem is of the 2nd or 3rd form, then A is overwritten with
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i A_i U_i^H, & \: \text{or}\newline
  !>
  !>         L_i^H A_i L_i,
  !>         \end{array}
  !>     \f]
  !> 
  !>     also depending on the value of uplo.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored, and
  !>               whether the factorization applied to B_i was upper or lower triangular.
  !>               If uplo indicates lower (or upper), then the upper (or lower) parts of A_i and
  !>               B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the matrices A_i. On exit, the transformed matrices associated with
  !>               the equivalent standard eigenvalue problems.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               The triangular factors of the matrices B_i, as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use case is strideB >= ldb*n.
  !>     @param[in]
  !>     batch_count  rocblas_int. batch_count >= 0.\n
  !>                  Number of matrices in the batch.
  !>
  interface rocsolver_chegst_strided_batched
    function rocsolver_chegst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_chegst_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegst_strided_batched_full_rank,&
      rocsolver_chegst_strided_batched_rank_0,&
      rocsolver_chegst_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegst_strided_batched
    function rocsolver_zhegst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count) bind(c, name="rocsolver_zhegst_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegst_strided_batched_full_rank,&
      rocsolver_zhegst_strided_batched_rank_0,&
      rocsolver_zhegst_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYEV computes the eigenvalues and optionally the eigenvectors of a real symmetric
  !>     matrix A.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed depending
  !>     on the value of evect. The computed eigenvectors are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the symmetric matrix A is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A. On exit, the eigenvectors of A if they were computed and
  !>                 the algorithm converged; otherwise the contents of A are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrix A.
  !>     @param[out]
  !>     D           pointer to type. Array on the GPU of dimension n.\n
  !>                 The eigenvalues of A in increasing order.
  !>     @param[out]
  !>     E           pointer to type. Array on the GPU of dimension n.\n
  !>                 This array is used to work internally with the tridiagonal matrix T associated with A.
  !>                 On exit, if info > 0, it contains the unconverged off-diagonal elements of T
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>                 of this matrix are in D; those that converged correspond to a subset of the
  !>                 eigenvalues of A (not necessarily ordered).
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit. If info = i > 0, the algorithm did not converge.
  !>                 i elements of E did not converge to zero.
  !>
  interface rocsolver_ssyev
    function rocsolver_ssyev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_ssyev")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssyev_full_rank,&
      rocsolver_ssyev_rank_0,&
      rocsolver_ssyev_rank_1
#endif
  end interface
  
  interface rocsolver_dsyev
    function rocsolver_dsyev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_dsyev")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsyev_full_rank,&
      rocsolver_dsyev_rank_0,&
      rocsolver_dsyev_rank_1
#endif
  end interface
  !>     \brief HEEV computes the eigenvalues and optionally the eigenvectors of a Hermitian matrix A.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed depending
  !>     on the value of evect. The computed eigenvectors are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the Hermitian matrix A is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A. On exit, the eigenvectors of A if they were computed and
  !>                 the algorithm converged; otherwise the contents of A are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrix A.
  !>     @param[out]
  !>     D           pointer to real type. Array on the GPU of dimension n.\n
  !>                 The eigenvalues of A in increasing order.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU of dimension n.\n
  !>                 This array is used to work internally with the tridiagonal matrix T associated with A.
  !>                 On exit, if info > 0, it contains the unconverged off-diagonal elements of T
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>                 of this matrix are in D; those that converged correspond to a subset of the
  !>                 eigenvalues of A (not necessarily ordered).
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit. If info = i > 0, the algorithm did not converge.
  !>                 i elements of E did not converge to zero.
  !>
  interface rocsolver_cheev
    function rocsolver_cheev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_cheev")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cheev_full_rank,&
      rocsolver_cheev_rank_0,&
      rocsolver_cheev_rank_1
#endif
  end interface
  
  interface rocsolver_zheev
    function rocsolver_zheev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_zheev")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zheev_full_rank,&
      rocsolver_zheev_rank_0,&
      rocsolver_zheev_rank_1
#endif
  end interface
  !>     \brief SYEV_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     real symmetric matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed depending
  !>     on the value of evect. The computed eigenvectors are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the symmetric matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     D           pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssyev_batched
    function rocsolver_ssyev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssyev_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssyev_batched_full_rank,&
      rocsolver_ssyev_batched_rank_0,&
      rocsolver_ssyev_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsyev_batched
    function rocsolver_dsyev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsyev_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsyev_batched_full_rank,&
      rocsolver_dsyev_batched_rank_0,&
      rocsolver_dsyev_batched_rank_1
#endif
  end interface
  !>     \brief HEEV_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     Hermitian matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed depending
  !>     on the value of evect. The computed eigenvectors are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the Hermitian matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     D           pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_cheev_batched
    function rocsolver_cheev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_cheev_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cheev_batched_full_rank,&
      rocsolver_cheev_batched_rank_0,&
      rocsolver_cheev_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zheev_batched
    function rocsolver_zheev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zheev_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zheev_batched_full_rank,&
      rocsolver_zheev_batched_rank_0,&
      rocsolver_zheev_batched_rank_1
#endif
  end interface
  !>     \brief SYEV_STRIDED_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     real symmetric matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed depending
  !>     on the value of evect. The computed eigenvectors are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the symmetric matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D           pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssyev_strided_batched
    function rocsolver_ssyev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssyev_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssyev_strided_batched_full_rank,&
      rocsolver_ssyev_strided_batched_rank_0,&
      rocsolver_ssyev_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsyev_strided_batched
    function rocsolver_dsyev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsyev_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsyev_strided_batched_full_rank,&
      rocsolver_dsyev_strided_batched_rank_0,&
      rocsolver_dsyev_strided_batched_rank_1
#endif
  end interface
  !>     \brief HEEV_STRIDED_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     Hermitian matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed depending
  !>     on the value of evect. The computed eigenvectors are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the Hermitian matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D           pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_cheev_strided_batched
    function rocsolver_cheev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_cheev_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cheev_strided_batched_full_rank,&
      rocsolver_cheev_strided_batched_rank_0,&
      rocsolver_cheev_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zheev_strided_batched
    function rocsolver_zheev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zheev_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zheev_strided_batched_full_rank,&
      rocsolver_zheev_strided_batched_rank_0,&
      rocsolver_zheev_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYEVD computes the eigenvalues and optionally the eigenvectors of a real symmetric
  !>     matrix A.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed using a
  !>     divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors
  !>     are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the symmetric matrix A is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A. On exit, the eigenvectors of A if they were computed and
  !>                 the algorithm converged; otherwise the contents of A are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrix A.
  !>     @param[out]
  !>     D           pointer to type. Array on the GPU of dimension n.\n
  !>                 The eigenvalues of A in increasing order.
  !>     @param[out]
  !>     E           pointer to type. Array on the GPU of dimension n.\n
  !>                 This array is used to work internally with the tridiagonal matrix T associated with A.
  !>                 On exit, if info > 0, it contains the unconverged off-diagonal elements of T
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>                 of this matrix are in D; those that converged correspond to a subset of the
  !>                 eigenvalues of A (not necessarily ordered).
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit.
  !>                 If info = i > 0 and evect is rocblas_evect_none, the algorithm did not converge.
  !>                 i elements of E did not converge to zero.
  !>                 If info = i > 0 and evect is rocblas_evect_original, the algorithm failed to
  !>                 compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
  !>
  interface rocsolver_ssyevd
    function rocsolver_ssyevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_ssyevd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssyevd_full_rank,&
      rocsolver_ssyevd_rank_0,&
      rocsolver_ssyevd_rank_1
#endif
  end interface
  
  interface rocsolver_dsyevd
    function rocsolver_dsyevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_dsyevd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsyevd_full_rank,&
      rocsolver_dsyevd_rank_0,&
      rocsolver_dsyevd_rank_1
#endif
  end interface
  !>     \brief HEEVD computes the eigenvalues and optionally the eigenvectors of a Hermitian matrix A.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed using a
  !>     divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors
  !>     are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the Hermitian matrix A is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrix A.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrix A. On exit, the eigenvectors of A if they were computed and
  !>                 the algorithm converged; otherwise the contents of A are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrix A.
  !>     @param[out]
  !>     D           pointer to real type. Array on the GPU of dimension n.\n
  !>                 The eigenvalues of A in increasing order.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU of dimension n.\n
  !>                 This array is used to work internally with the tridiagonal matrix T associated with A.
  !>                 On exit, if info > 0, it contains the unconverged off-diagonal elements of T
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>                 of this matrix are in D; those that converged correspond to a subset of the
  !>                 eigenvalues of A (not necessarily ordered).
  !>     @param[out]
  !>     info        pointer to a rocblas_int on the GPU.\n
  !>                 If info = 0, successful exit.
  !>                 If info = i > 0 and evect is rocblas_evect_none, the algorithm did not converge.
  !>                 i elements of E did not converge to zero.
  !>                 If info = i > 0 and evect is rocblas_evect_original, the algorithm failed to
  !>                 compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
  !>
  interface rocsolver_cheevd
    function rocsolver_cheevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_cheevd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cheevd_full_rank,&
      rocsolver_cheevd_rank_0,&
      rocsolver_cheevd_rank_1
#endif
  end interface
  
  interface rocsolver_zheevd
    function rocsolver_zheevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_zheevd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zheevd_full_rank,&
      rocsolver_zheevd_rank_0,&
      rocsolver_zheevd_rank_1
#endif
  end interface
  !>     \brief SYEVD_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     real symmetric matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed using a
  !>     divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors
  !>     are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the symmetric matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     D           pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_none, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_original, the algorithm failed to
  !>                 compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssyevd_batched
    function rocsolver_ssyevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssyevd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssyevd_batched_full_rank,&
      rocsolver_ssyevd_batched_rank_0,&
      rocsolver_ssyevd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsyevd_batched
    function rocsolver_dsyevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsyevd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsyevd_batched_full_rank,&
      rocsolver_dsyevd_batched_rank_0,&
      rocsolver_dsyevd_batched_rank_1
#endif
  end interface
  !>     \brief HEEVD_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     Hermitian matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed using a
  !>     divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors
  !>     are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the Hermitian matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     D           pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_none, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_original, the algorithm failed to
  !>                 compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_cheevd_batched
    function rocsolver_cheevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_cheevd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cheevd_batched_full_rank,&
      rocsolver_cheevd_batched_rank_0,&
      rocsolver_cheevd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zheevd_batched
    function rocsolver_zheevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zheevd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zheevd_batched_full_rank,&
      rocsolver_zheevd_batched_rank_0,&
      rocsolver_zheevd_batched_rank_1
#endif
  end interface
  !>     \brief SYEVD_STRIDED_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     real symmetric matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed using a
  !>     divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors
  !>     are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the symmetric matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D           pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_none, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_original, the algorithm failed to
  !>                 compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssyevd_strided_batched
    function rocsolver_ssyevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssyevd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssyevd_strided_batched_full_rank,&
      rocsolver_ssyevd_strided_batched_rank_0,&
      rocsolver_ssyevd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsyevd_strided_batched
    function rocsolver_dsyevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsyevd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsyevd_strided_batched_full_rank,&
      rocsolver_dsyevd_strided_batched_rank_0,&
      rocsolver_dsyevd_strided_batched_rank_1
#endif
  end interface
  !>     \brief HEEVD_STRIDED_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of
  !>     Hermitian matrices A_j.
  !> 
  !>     \details
  !>     The eigenvalues are returned in ascending order. The eigenvectors are computed using a
  !>     divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors
  !>     are orthonormal.
  !> 
  !>     @param[in]
  !>     handle      rocblas_handle.
  !>     @param[in]
  !>     evect       rocblas_evect.\n
  !>                 Specifies whether the eigenvectors are to be computed.
  !>                 If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>                 rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo        rocblas_fill.\n
  !>                 Specifies whether the upper or lower part of the Hermitian matrices A_j is stored.
  !>                 If uplo indicates lower (or upper), then the upper (or lower) part of A_j
  !>                 is not used.
  !>     @param[in]
  !>     n           rocblas_int. n >= 0.\n
  !>                 Number of rows and columns of matrices A_j.
  !>     @param[inout]
  !>     A           pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>                 On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and
  !>                 the algorithm converged; otherwise the contents of A_j are destroyed.
  !>     @param[in]
  !>     lda         rocblas_int. lda >= n.\n
  !>                 Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA     rocblas_stride.\n
  !>                 Stride from the start of one matrix A_j to the next one A_(j+1).
  !>                 There is no restriction for the value of strideA. Normal use case is strideA >= lda*n.
  !>     @param[out]
  !>     D           pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>                 The eigenvalues of A_j in increasing order.
  !>     @param[in]
  !>     strideD     rocblas_stride.\n
  !>                 Stride from the start of one vector D_j to the next one D_(j+1).
  !>                 There is no restriction for the value of strideD. Normal use case is strideD >= n.
  !>     @param[out]
  !>     E           pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>                 This array is used to work internally with the tridiagonal matrix T_j associated with A_j.
  !>                 On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j
  !>                 (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements
  !>                 of this matrix are in D_j; those that converged correspond to a subset of the
  !>                 eigenvalues of A_j (not necessarily ordered).
  !>     @param[in]
  !>     strideE     rocblas_stride.\n
  !>                 Stride from the start of one vector E_j to the next one E_(j+1).
  !>                 There is no restriction for the value of strideE. Normal use case is strideE >= n.
  !>     @param[out]
  !>     info        pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>                 If info[j] = 0, successful exit for matrix A_j.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_none, the algorithm did not converge.
  !>                 i elements of E_j did not converge to zero.
  !>                 If info[j] = i > 0 and evect is rocblas_evect_original, the algorithm failed to
  !>                 compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_cheevd_strided_batched
    function rocsolver_cheevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_cheevd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cheevd_strided_batched_full_rank,&
      rocsolver_cheevd_strided_batched_rank_0,&
      rocsolver_cheevd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zheevd_strided_batched
    function rocsolver_zheevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zheevd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zheevd_strided_batched_full_rank,&
      rocsolver_zheevd_strided_batched_rank_0,&
      rocsolver_zheevd_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYGV computes the eigenvalues and (optionally) eigenvectors of
  !>     a real generalized symmetric-definite eigenproblem.
  !> 
  !>     \details
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix Z of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z^T B Z=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z^T B^{-1} Z=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A and B are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A and B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrix A. On exit, if evect is original,
  !>               the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrix A (including the diagonal) is destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               On entry, the symmetric positive definite matrix B. On exit, the
  !>               triangular factor of B as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU of dimension n.\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU of dimension n.\n
  !>               This array is used to work internally with the tridiagonal matrix T associated with
  !>               the reduced eigenvalue problem.
  !>               On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T
  !>               (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>               of this matrix are in D; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j <= n, j off-diagonal elements of an intermediate
  !>               tridiagonal form did not converge to zero.
  !>               If info = n + j, the leading minor of order j of B is not
  !>               positive definite.
  !>
  interface rocsolver_ssygv
    function rocsolver_ssygv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_ssygv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygv_full_rank,&
      rocsolver_ssygv_rank_0,&
      rocsolver_ssygv_rank_1
#endif
  end interface
  
  interface rocsolver_dsygv
    function rocsolver_dsygv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_dsygv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygv_full_rank,&
      rocsolver_dsygv_rank_0,&
      rocsolver_dsygv_rank_1
#endif
  end interface
  !>     \brief HEGV computes the eigenvalues and (optionally) eigenvectors of
  !>     a complex generalized hermitian-definite eigenproblem.
  !> 
  !>     \details
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix Z of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z^H B Z=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z^H B^{-1} Z=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A and B are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A and B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the hermitian matrix A. On exit, if evect is original,
  !>               the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrix A (including the diagonal) is destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               On entry, the hermitian positive definite matrix B. On exit, the
  !>               triangular factor of B as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension n.\n
  !>               This array is used to work internally with the tridiagonal matrix T associated with
  !>               the reduced eigenvalue problem.
  !>               On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T
  !>               (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>               of this matrix are in D; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j <= n, j off-diagonal elements of an intermediate
  !>               tridiagonal form did not converge to zero.
  !>               If info = n + j, the leading minor of order j of B is not
  !>               positive definite.
  !>
  interface rocsolver_chegv
    function rocsolver_chegv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_chegv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegv_full_rank,&
      rocsolver_chegv_rank_0,&
      rocsolver_chegv_rank_1
#endif
  end interface
  
  interface rocsolver_zhegv
    function rocsolver_zhegv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_zhegv")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegv_full_rank,&
      rocsolver_zhegv_rank_0,&
      rocsolver_zhegv_rank_1
#endif
  end interface
  !>     \brief SYGV_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of real generalized symmetric-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^T B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^T B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               On entry, the symmetric positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, E_i contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch instance i.
  !>               If info[i] = j <= n, j off-diagonal elements of an intermediate
  !>               tridiagonal form did not converge to zero.
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssygv_batched
    function rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssygv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygv_batched_full_rank,&
      rocsolver_ssygv_batched_rank_0,&
      rocsolver_ssygv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygv_batched
    function rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsygv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygv_batched_full_rank,&
      rocsolver_dsygv_batched_rank_0,&
      rocsolver_dsygv_batched_rank_1
#endif
  end interface
  !>     \brief HEGV_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^H B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^H B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the hermitian matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               On entry, the hermitian positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n, j off-diagonal elements of an intermediate
  !>               tridiagonal form did not converge to zero.
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_chegv_batched
    function rocsolver_chegv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_chegv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegv_batched_full_rank,&
      rocsolver_chegv_batched_rank_0,&
      rocsolver_chegv_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegv_batched
    function rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zhegv_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegv_batched_full_rank,&
      rocsolver_zhegv_batched_rank_0,&
      rocsolver_zhegv_batched_rank_1
#endif
  end interface
  !>     \brief SYGV_STRIDED_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of real generalized symmetric-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^T B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^T B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the symmetric matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               On entry, the symmetric positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use is strideB >= ldb*n.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n, j off-diagonal elements of an intermediate
  !>               tridiagonal form did not converge to zero.
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssygv_strided_batched
    function rocsolver_ssygv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssygv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygv_strided_batched_full_rank,&
      rocsolver_ssygv_strided_batched_rank_0,&
      rocsolver_ssygv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygv_strided_batched
    function rocsolver_dsygv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsygv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygv_strided_batched_full_rank,&
      rocsolver_dsygv_strided_batched_rank_0,&
      rocsolver_dsygv_strided_batched_rank_1
#endif
  end interface
  !>     \brief HEGV_STRIDED_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^H B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^H B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the hermitian matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               On entry, the hermitian positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use is strideB >= ldb*n.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n, j off-diagonal elements of an intermediate
  !>               tridiagonal form did not converge to zero.
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_chegv_strided_batched
    function rocsolver_chegv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_chegv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegv_strided_batched_full_rank,&
      rocsolver_chegv_strided_batched_rank_0,&
      rocsolver_chegv_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegv_strided_batched
    function rocsolver_zhegv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zhegv_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegv_strided_batched_full_rank,&
      rocsolver_zhegv_strided_batched_rank_0,&
      rocsolver_zhegv_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYGVD computes the eigenvalues and (optionally) eigenvectors of
  !>     a real generalized symmetric-definite eigenproblem.
  !> 
  !>     \details
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix Z of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z^T B Z=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z^T B^{-1} Z=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A and B are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A and B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrix A. On exit, if evect is original,
  !>               the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrix A (including the diagonal) is destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               On entry, the symmetric positive definite matrix B. On exit, the
  !>               triangular factor of B as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU of dimension n.\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU of dimension n.\n
  !>               This array is used to work internally with the tridiagonal matrix T associated with
  !>               the reduced eigenvalue problem.
  !>               On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T
  !>               (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>               of this matrix are in D; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j <= n and evect is rocblas_evect_none, j off-diagonal elements of an
  !>               intermediate tridiagonal form did not converge to zero.
  !>               If info = j <= n and evect is rocblas_evect_original, the algorithm failed to
  !>               compute an eigenvalue in the submatrix from [j/(n+1), j/(n+1)] to [j%(n+1), j%(n+1)].
  !>               If info = n + j, the leading minor of order j of B is not
  !>               positive definite.
  !>
  interface rocsolver_ssygvd
    function rocsolver_ssygvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_ssygvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygvd_full_rank,&
      rocsolver_ssygvd_rank_0,&
      rocsolver_ssygvd_rank_1
#endif
  end interface
  
  interface rocsolver_dsygvd
    function rocsolver_dsygvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_dsygvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygvd_full_rank,&
      rocsolver_dsygvd_rank_0,&
      rocsolver_dsygvd_rank_1
#endif
  end interface
  !>     \brief HEGVD computes the eigenvalues and (optionally) eigenvectors of
  !>     a complex generalized hermitian-definite eigenproblem.
  !> 
  !>     \details
  !>     The problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A X = \lambda B X & \: \text{1st form,}\newline
  !>
  !>         A B X = \lambda X & \: \text{2nd form, or}\newline
  !>
  !>         B A X = \lambda X & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix Z of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z^H B Z=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z^H B^{-1} Z=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblem.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A and B are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A and B are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the hermitian matrix A. On exit, if evect is original,
  !>               the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrix A (including the diagonal) is destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU of dimension ldb*n.\n
  !>               On entry, the hermitian positive definite matrix B. On exit, the
  !>               triangular factor of B as returned by \ref rocsolver_spotrf "POTRF".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU of dimension n.\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU of dimension n.\n
  !>               This array is used to work internally with the tridiagonal matrix T associated with
  !>               the reduced eigenvalue problem.
  !>               On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T
  !>               (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements
  !>               of this matrix are in D; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = j <= n and evect is rocblas_evect_none, j off-diagonal elements of an
  !>               intermediate tridiagonal form did not converge to zero.
  !>               If info = j <= n and evect is rocblas_evect_original, the algorithm failed to
  !>               compute an eigenvalue in the submatrix from [j/(n+1), j/(n+1)] to [j%(n+1), j%(n+1)].
  !>               If info = n + j, the leading minor of order j of B is not
  !>               positive definite.
  !>
  interface rocsolver_chegvd
    function rocsolver_chegvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_chegvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegvd_full_rank,&
      rocsolver_chegvd_rank_0,&
      rocsolver_chegvd_rank_1
#endif
  end interface
  
  interface rocsolver_zhegvd
    function rocsolver_zhegvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) bind(c, name="rocsolver_zhegvd")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      type(c_ptr),value :: E
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegvd_full_rank,&
      rocsolver_zhegvd_rank_0,&
      rocsolver_zhegvd_rank_1
#endif
  end interface
  !>     \brief SYGVD_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of real generalized symmetric-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^T B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^T B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               On entry, the symmetric positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n and evect is rocblas_evect_none, j off-diagonal elements of an
  !>               intermediate tridiagonal form did not converge to zero.
  !>               If info[i] = j <= n and evect is rocblas_evect_original, the algorithm failed to
  !>               compute an eigenvalue in the submatrix from [j/(n+1), j/(n+1)] to [j%(n+1), j%(n+1)].
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssygvd_batched
    function rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssygvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygvd_batched_full_rank,&
      rocsolver_ssygvd_batched_rank_0,&
      rocsolver_ssygvd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygvd_batched
    function rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsygvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygvd_batched_full_rank,&
      rocsolver_dsygvd_batched_rank_0,&
      rocsolver_dsygvd_batched_rank_1
#endif
  end interface
  !>     \brief HEGVD_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^H B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^H B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the hermitian matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[out]
  !>     B         array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.\n
  !>               On entry, the hermitian positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_batched "POTRF_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n and evect is rocblas_evect_none, j off-diagonal elements of an
  !>               intermediate tridiagonal form did not converge to zero.
  !>               If info[i] = j <= n and evect is rocblas_evect_original, the algorithm failed to
  !>               compute an eigenvalue in the submatrix from [j/(n+1), j/(n+1)] to [j%(n+1), j%(n+1)].
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_chegvd_batched
    function rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_chegvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegvd_batched_full_rank,&
      rocsolver_chegvd_batched_rank_0,&
      rocsolver_chegvd_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegvd_batched
    function rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zhegvd_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: B
      integer(c_int),value :: ldb
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegvd_batched_full_rank,&
      rocsolver_zhegvd_batched_rank_0,&
      rocsolver_zhegvd_batched_rank_1
#endif
  end interface
  !>     \brief SYGVD_STRIDED_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of real generalized symmetric-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^T B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^T B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the symmetric matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               On entry, the symmetric positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use is strideB >= ldb*n.
  !>     @param[out]
  !>     D         pointer to type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n and evect is rocblas_evect_none, j off-diagonal elements of an
  !>               intermediate tridiagonal form did not converge to zero.
  !>               If info[i] = j <= n and evect is rocblas_evect_original, the algorithm failed to
  !>               compute an eigenvalue in the submatrix from [j/(n+1), j/(n+1)] to [j%(n+1), j%(n+1)].
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_ssygvd_strided_batched
    function rocsolver_ssygvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_ssygvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssygvd_strided_batched_full_rank,&
      rocsolver_ssygvd_strided_batched_rank_0,&
      rocsolver_ssygvd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsygvd_strided_batched
    function rocsolver_dsygvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_dsygvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsygvd_strided_batched_full_rank,&
      rocsolver_dsygvd_strided_batched_rank_0,&
      rocsolver_dsygvd_strided_batched_rank_1
#endif
  end interface
  !>     \brief HEGVD_STRIDED_BATCHED computes the eigenvalues and (optionally)
  !>     eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.
  !> 
  !>     \details
  !>     For each instance in the batch, the problem solved by this function is either of the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i X_i = \lambda B_i X_i & \: \text{1st form,}\newline
  !>
  !>         A_i B_i X_i = \lambda X_i & \: \text{2nd form, or}\newline
  !>
  !>         B_i A_i X_i = \lambda X_i & \: \text{3rd form,}
  !>         \end{array}
  !>     \f]
  !> 
  !>     depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the
  !>     value of evect.
  !> 
  !>     When computed, the matrix \f$Z_i\f$ of eigenvectors is normalized as follows:
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         Z_i^H B_i Z_i=I & \: \text{if 1st or 2nd form, or}\newline
  !>
  !>         Z_i^H B_i^{-1} Z_i=I & \: \text{if 3rd form.}
  !>         \end{array}
  !>     \f]
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     itype     rocblas_eform.\n
  !>               Specifies the form of the generalized eigenproblems.
  !>     @param[in]
  !>     evect     rocblas_evect.\n
  !>               Specifies whether the eigenvectors are to be computed.
  !>               If evect is rocblas_evect_original, then the eigenvectors are computed.
  !>               rocblas_evect_tridiagonal is not supported.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower parts of the matrices
  !>               A_i and B_i are stored. If uplo indicates lower (or upper),
  !>               then the upper (or lower) parts of A_i and B_i are not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The matrix dimensions.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the hermitian matrices A_i. On exit, if evect is original,
  !>               the normalized matrix Z_i of eigenvectors. If evect is none, then the upper or lower triangular
  !>               part of the matrices A_i (including the diagonal) are destroyed,
  !>               depending on the value of uplo.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use is strideA >= lda*n.
  !>     @param[out]
  !>     B         pointer to type. Array on the GPU (the size depends on the value of strideB).\n
  !>               On entry, the hermitian positive definite matrices B_i. On exit, the
  !>               triangular factor of B_i as returned by \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     ldb       rocblas_int. ldb >= n.\n
  !>               Specifies the leading dimension of B_i.
  !>     @param[in]
  !>     strideB   rocblas_stride.\n
  !>               Stride from the start of one matrix B_i to the next one B_(i+1).
  !>               There is no restriction for the value of strideB. Normal use is strideB >= ldb*n.
  !>     @param[out]
  !>     D         pointer to real type. Array on the GPU (the size depends on the value of strideD).\n
  !>               On exit, the eigenvalues in increasing order.
  !>     @param[in]
  !>     strideD   rocblas_stride.\n
  !>               Stride from the start of one vector D_i to the next one D_(i+1).
  !>               There is no restriction for the value of strideD. Normal use is strideD >= n.
  !>     @param[out]
  !>     E         pointer to real type. Array on the GPU (the size depends on the value of strideE).\n
  !>               This array is used to work internally with the tridiagonal matrix T_i associated with
  !>               the ith reduced eigenvalue problem.
  !>               On exit, if 0 < info[i] <= n, it contains the unconverged off-diagonal elements of T_i
  !>               (or properly speaking, a tridiagonal matrix equivalent to T_i). The diagonal elements
  !>               of this matrix are in D_i; those that converged correspond to a subset of the
  !>               eigenvalues (not necessarily ordered).
  !>     @param[in]
  !>     strideE   rocblas_stride.\n
  !>               Stride from the start of one vector E_i to the next one E_(i+1).
  !>               There is no restriction for the value of strideE. Normal use is strideE >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit of batch i.
  !>               If info[i] = j <= n and evect is rocblas_evect_none, j off-diagonal elements of an
  !>               intermediate tridiagonal form did not converge to zero.
  !>               If info[i] = j <= n and evect is rocblas_evect_original, the algorithm failed to
  !>               compute an eigenvalue in the submatrix from [j/(n+1), j/(n+1)] to [j%(n+1), j%(n+1)].
  !>               If info[i] = n + j, the leading minor of order j of B_i is not
  !>               positive definite.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_chegvd_strided_batched
    function rocsolver_chegvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_chegvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_chegvd_strided_batched_full_rank,&
      rocsolver_chegvd_strided_batched_rank_0,&
      rocsolver_chegvd_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zhegvd_strided_batched
    function rocsolver_zhegvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) bind(c, name="rocsolver_zhegvd_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_eform_ax)),value :: itype
      integer(kind(rocblas_evect_original)),value :: evect
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: B
      integer(c_int),value :: ldb
      integer(c_int64_t),value :: strideB
      type(c_ptr),value :: D
      integer(c_int64_t),value :: strideD
      type(c_ptr),value :: E
      integer(c_int64_t),value :: strideE
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zhegvd_strided_batched_full_rank,&
      rocsolver_zhegvd_strided_batched_rank_0,&
      rocsolver_zhegvd_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_OUTOFPLACE computes the inverse \f$C = A^{-1}\f$ of a general n-by-n matrix A.
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         AC = I
  !>     \f]
  !> 
  !>     where I is the identity matrix, and A is factorized as \f$A = PLU\f$ as given by \ref rocsolver_sgetrf "GETRF".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[in]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               The factors L and U of the factorization A = P*L*U returned by \ref rocsolver_sgetrf "GETRF".
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[in]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The pivot indices returned by \ref rocsolver_sgetrf "GETRF".
  !>     @param[out]
  !>     C         pointer to type. Array on the GPU of dimension ldc*n.\n
  !>               If info = 0, the inverse of A. Otherwise, undefined.
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n.\n
  !>               Specifies the leading dimension of C.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, U is singular. U[i,i] is the first zero pivot.
  !>
  interface rocsolver_sgetri_outofplace
    function rocsolver_sgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) bind(c, name="rocsolver_sgetri_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_outofplace_full_rank,&
      rocsolver_sgetri_outofplace_rank_0,&
      rocsolver_sgetri_outofplace_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_outofplace
    function rocsolver_dgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) bind(c, name="rocsolver_dgetri_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_outofplace_full_rank,&
      rocsolver_dgetri_outofplace_rank_0,&
      rocsolver_dgetri_outofplace_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_outofplace
    function rocsolver_cgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) bind(c, name="rocsolver_cgetri_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_outofplace_full_rank,&
      rocsolver_cgetri_outofplace_rank_0,&
      rocsolver_cgetri_outofplace_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_outofplace
    function rocsolver_zgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) bind(c, name="rocsolver_zgetri_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_outofplace_full_rank,&
      rocsolver_zgetri_outofplace_rank_0,&
      rocsolver_zgetri_outofplace_rank_1
#endif
  end interface
  !>     \brief GETRI_OUTOFPLACE_BATCHED computes the inverse \f$C_j = A_j^{-1}\f$ of a batch of general n-by-n matrices \f$A_j\f$.
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j C_j = I
  !>     \f]
  !> 
  !>     where I is the identity matrix, and \f$A_j\f$ is factorized as \f$A_j = P_j  L_j  U_j\f$ as given by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[in]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               The factors L_j and U_j of the factorization A_j = P_j*L_j*U_j returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               The pivot indices returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED".
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(i+j).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     C         array of pointers to type. Each pointer points to an array on the GPU of dimension ldc*n.\n
  !>               If info[j] = 0, the inverse of matrices A_j. Otherwise, undefined.
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n.\n
  !>               Specifies the leading dimension of C_j.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_outofplace_batched
    function rocsolver_sgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_sgetri_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_outofplace_batched_full_rank,&
      rocsolver_sgetri_outofplace_batched_rank_0,&
      rocsolver_sgetri_outofplace_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_outofplace_batched
    function rocsolver_dgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_dgetri_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_outofplace_batched_full_rank,&
      rocsolver_dgetri_outofplace_batched_rank_0,&
      rocsolver_dgetri_outofplace_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_outofplace_batched
    function rocsolver_cgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_cgetri_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_outofplace_batched_full_rank,&
      rocsolver_cgetri_outofplace_batched_rank_0,&
      rocsolver_cgetri_outofplace_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_outofplace_batched
    function rocsolver_zgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_zgetri_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_outofplace_batched_full_rank,&
      rocsolver_zgetri_outofplace_batched_rank_0,&
      rocsolver_zgetri_outofplace_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_OUTOFPLACE_STRIDED_BATCHED computes the inverse \f$C_j = A_j^{-1}\f$ of a batch of general n-by-n matrices \f$A_j\f$.
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j C_j = I
  !>     \f]
  !> 
  !>     where I is the identity matrix, and \f$A_j\f$ is factorized as \f$A_j = P_j  L_j  U_j\f$ as given by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[in]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               The factors L_j and U_j of the factorization A_j = P_j*L_j*U_j returned by
  !>               \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[in]
  !>     ipiv      pointer to rocblas_int. Array on the GPU (the size depends on the value of strideP).\n
  !>               The pivot indices returned by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED".
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_j to the next one ipiv_(j+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     C         pointer to type. Array on the GPU (the size depends on the value of strideC).\n
  !>               If info[j] = 0, the inverse of matrices A_j. Otherwise, undefined.
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n.\n
  !>               Specifies the leading dimension of C_j.
  !>     @param[in]
  !>     strideC   rocblas_stride.\n
  !>               Stride from the start of one matrix C_j to the next one C_(j+1).
  !>               There is no restriction for the value of strideC. Normal use case is strideC >= ldc*n
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_outofplace_strided_batched
    function rocsolver_sgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_sgetri_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_outofplace_strided_batched_full_rank,&
      rocsolver_sgetri_outofplace_strided_batched_rank_0,&
      rocsolver_sgetri_outofplace_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_outofplace_strided_batched
    function rocsolver_dgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_dgetri_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_outofplace_strided_batched_full_rank,&
      rocsolver_dgetri_outofplace_strided_batched_rank_0,&
      rocsolver_dgetri_outofplace_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_outofplace_strided_batched
    function rocsolver_cgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_cgetri_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_outofplace_strided_batched_full_rank,&
      rocsolver_cgetri_outofplace_strided_batched_rank_0,&
      rocsolver_cgetri_outofplace_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_outofplace_strided_batched
    function rocsolver_zgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_zgetri_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_outofplace_strided_batched_full_rank,&
      rocsolver_zgetri_outofplace_strided_batched_rank_0,&
      rocsolver_zgetri_outofplace_strided_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_NPVT_OUTOFPLACE computes the inverse \f$C = A^{-1}\f$ of a general n-by-n matrix A without partial pivoting.
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         AC = I
  !>     \f]
  !> 
  !>     where I is the identity matrix, and A is factorized as \f$A = LU\f$ as given by \ref rocsolver_sgetrf_npvt "GETRF_NPVT".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[in]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               The factors L and U of the factorization A = L*U returned by \ref rocsolver_sgetrf_npvt "GETRF_NPVT".
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     C         pointer to type. Array on the GPU of dimension ldc*n.\n
  !>               If info = 0, the inverse of A. Otherwise, undefined.
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n.\n
  !>               Specifies the leading dimension of C.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, U is singular. U[i,i] is the first zero pivot.
  !>
  interface rocsolver_sgetri_npvt_outofplace
    function rocsolver_sgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) bind(c, name="rocsolver_sgetri_npvt_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_npvt_outofplace_full_rank,&
      rocsolver_sgetri_npvt_outofplace_rank_0,&
      rocsolver_sgetri_npvt_outofplace_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_npvt_outofplace
    function rocsolver_dgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) bind(c, name="rocsolver_dgetri_npvt_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_npvt_outofplace_full_rank,&
      rocsolver_dgetri_npvt_outofplace_rank_0,&
      rocsolver_dgetri_npvt_outofplace_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_npvt_outofplace
    function rocsolver_cgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) bind(c, name="rocsolver_cgetri_npvt_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_npvt_outofplace_full_rank,&
      rocsolver_cgetri_npvt_outofplace_rank_0,&
      rocsolver_cgetri_npvt_outofplace_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_npvt_outofplace
    function rocsolver_zgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) bind(c, name="rocsolver_zgetri_npvt_outofplace")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_npvt_outofplace_full_rank,&
      rocsolver_zgetri_npvt_outofplace_rank_0,&
      rocsolver_zgetri_npvt_outofplace_rank_1
#endif
  end interface
  !>     \brief GETRI_NPVT_OUTOFPLACE_BATCHED computes the inverse \f$C_j = A_j^{-1}\f$ of a batch of general n-by-n matrices \f$A_j\f$
  !>     without partial pivoting.
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j C_j = I
  !>     \f]
  !> 
  !>     where I is the identity matrix, and \f$A_j\f$ is factorized as \f$A_j = L_j  U_j\f$ as given by \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[in]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               The factors L_j and U_j of the factorization A_j = L_j*U_j returned by \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED".
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     C         array of pointers to type. Each pointer points to an array on the GPU of dimension ldc*n.\n
  !>               If info[j] = 0, the inverse of matrices A_j. Otherwise, undefined.
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n.\n
  !>               Specifies the leading dimension of C_j.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_npvt_outofplace_batched
    function rocsolver_sgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_sgetri_npvt_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_npvt_outofplace_batched_full_rank,&
      rocsolver_sgetri_npvt_outofplace_batched_rank_0,&
      rocsolver_sgetri_npvt_outofplace_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_npvt_outofplace_batched
    function rocsolver_dgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_dgetri_npvt_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_npvt_outofplace_batched_full_rank,&
      rocsolver_dgetri_npvt_outofplace_batched_rank_0,&
      rocsolver_dgetri_npvt_outofplace_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_npvt_outofplace_batched
    function rocsolver_cgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_cgetri_npvt_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_npvt_outofplace_batched_full_rank,&
      rocsolver_cgetri_npvt_outofplace_batched_rank_0,&
      rocsolver_cgetri_npvt_outofplace_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_npvt_outofplace_batched
    function rocsolver_zgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) bind(c, name="rocsolver_zgetri_npvt_outofplace_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr) :: C
      integer(c_int),value :: ldc
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_npvt_outofplace_batched_full_rank,&
      rocsolver_zgetri_npvt_outofplace_batched_rank_0,&
      rocsolver_zgetri_npvt_outofplace_batched_rank_1
#endif
  end interface
  !>     \brief GETRI_NPVT_OUTOFPLACE_STRIDED_BATCHED computes the inverse \f$C_j = A_j^{-1}\f$ of a batch of general n-by-n matrices \f$A_j\f$
  !>     without partial pivoting.
  !> 
  !>     \details
  !>     The inverse is computed by solving the linear system
  !> 
  !>     \f[
  !>         A_j C_j = I
  !>     \f]
  !> 
  !>     where I is the identity matrix, and \f$A_j\f$ is factorized as \f$A_j = L_j  U_j\f$ as given by \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED".
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[in]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               The factors L_j and U_j of the factorization A_j = L_j*U_j returned by
  !>               \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED".
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     C         pointer to type. Array on the GPU (the size depends on the value of strideC).\n
  !>               If info[j] = 0, the inverse of matrices A_j. Otherwise, undefined.
  !>     @param[in]
  !>     ldc       rocblas_int. ldc >= n.\n
  !>               Specifies the leading dimension of C_j.
  !>     @param[in]
  !>     strideC   rocblas_stride.\n
  !>               Stride from the start of one matrix C_j to the next one C_(j+1).
  !>               There is no restriction for the value of strideC. Normal use case is strideC >= ldc*n
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_sgetri_npvt_outofplace_strided_batched
    function rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_sgetri_npvt_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank,&
      rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0,&
      rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dgetri_npvt_outofplace_strided_batched
    function rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_dgetri_npvt_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank,&
      rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0,&
      rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_cgetri_npvt_outofplace_strided_batched
    function rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_cgetri_npvt_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank,&
      rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0,&
      rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zgetri_npvt_outofplace_strided_batched
    function rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count) bind(c, name="rocsolver_zgetri_npvt_outofplace_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_
      type(c_ptr),value :: handle
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: C
      integer(c_int),value :: ldc
      integer(c_int64_t),value :: strideC
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank,&
      rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0,&
      rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1
#endif
  end interface
  !>     \brief TRTRI inverts a triangular n-by-n matrix A.
  !> 
  !>     \details
  !>     A can be upper or lower triangular, depending on the value of uplo, and unit or non-unit
  !>     triangular, depending on the value of diag.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     diag      rocblas_diagonal.\n
  !>               If diag indicates unit, then the diagonal elements of A are not referenced and
  !>               assumed to be one.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the triangular matrix.
  !>               On exit, the inverse of A if info = 0.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info = i > 0, A is singular. A[i,i] is the first zero element in the diagonal.
  !>
  interface rocsolver_strtri
    function rocsolver_strtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_strtri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_strtri_full_rank,&
      rocsolver_strtri_rank_0,&
      rocsolver_strtri_rank_1
#endif
  end interface
  
  interface rocsolver_dtrtri
    function rocsolver_dtrtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_dtrtri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dtrtri_full_rank,&
      rocsolver_dtrtri_rank_0,&
      rocsolver_dtrtri_rank_1
#endif
  end interface
  
  interface rocsolver_ctrtri
    function rocsolver_ctrtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_ctrtri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ctrtri_full_rank,&
      rocsolver_ctrtri_rank_0,&
      rocsolver_ctrtri_rank_1
#endif
  end interface
  
  interface rocsolver_ztrtri
    function rocsolver_ztrtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_ztrtri")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ztrtri_full_rank,&
      rocsolver_ztrtri_rank_0,&
      rocsolver_ztrtri_rank_1
#endif
  end interface
  !>     \brief TRTRI_BATCHED inverts a batch of triangular n-by-n matrices \f$A_j\f$.
  !> 
  !>     \details
  !>     \f$A_j\f$ can be upper or lower triangular, depending on the value of uplo, and unit or non-unit
  !>     triangular, depending on the value of diag.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_j are stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A_j is not used.
  !>     @param[in]
  !>     diag      rocblas_diagonal.\n
  !>               If diag indicates unit, then the diagonal elements of matrices A_j are not referenced and
  !>               assumed to be one.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the triangular matrices A_j.
  !>               On exit, the inverses of A_j if info[j] = 0.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, A_j is singular. A_j[i,i] is the first zero element in the diagonal.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_strtri_batched
    function rocsolver_strtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_strtri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_strtri_batched_full_rank,&
      rocsolver_strtri_batched_rank_0,&
      rocsolver_strtri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dtrtri_batched
    function rocsolver_dtrtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_dtrtri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dtrtri_batched_full_rank,&
      rocsolver_dtrtri_batched_rank_0,&
      rocsolver_dtrtri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_ctrtri_batched
    function rocsolver_ctrtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_ctrtri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ctrtri_batched_full_rank,&
      rocsolver_ctrtri_batched_rank_0,&
      rocsolver_ctrtri_batched_rank_1
#endif
  end interface
  
  interface rocsolver_ztrtri_batched
    function rocsolver_ztrtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) bind(c, name="rocsolver_ztrtri_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ztrtri_batched_full_rank,&
      rocsolver_ztrtri_batched_rank_0,&
      rocsolver_ztrtri_batched_rank_1
#endif
  end interface
  !>     \brief TRTRI_STRIDED_BATCHED inverts a batch of triangular n-by-n matrices \f$A_j\f$.
  !> 
  !>     \details
  !>     \f$A_j\f$ can be upper or lower triangular, depending on the value of uplo, and unit or non-unit
  !>     triangular, depending on the value of diag.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_j are stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A_j is not used.
  !>     @param[in]
  !>     diag      rocblas_diagonal.\n
  !>               If diag indicates unit, then the diagonal elements of matrices A_j are not referenced and
  !>               assumed to be one.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_j in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the triangular matrices A_j.
  !>               On exit, the inverses of A_j if info[j] = 0.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_j.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_j to the next one A_(j+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[j] = 0, successful exit for inversion of A_j.
  !>               If info[j] = i > 0, A_j is singular. A_j[i,i] is the first zero element in the diagonal.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  !>
  interface rocsolver_strtri_strided_batched
    function rocsolver_strtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_strtri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_strtri_strided_batched_full_rank,&
      rocsolver_strtri_strided_batched_rank_0,&
      rocsolver_strtri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dtrtri_strided_batched
    function rocsolver_dtrtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_dtrtri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dtrtri_strided_batched_full_rank,&
      rocsolver_dtrtri_strided_batched_rank_0,&
      rocsolver_dtrtri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_ctrtri_strided_batched
    function rocsolver_ctrtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_ctrtri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ctrtri_strided_batched_full_rank,&
      rocsolver_ctrtri_strided_batched_rank_0,&
      rocsolver_ctrtri_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_ztrtri_strided_batched
    function rocsolver_ztrtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count) bind(c, name="rocsolver_ztrtri_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(kind(rocblas_diagonal_non_unit)),value :: diag
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ztrtri_strided_batched_full_rank,&
      rocsolver_ztrtri_strided_batched_rank_0,&
      rocsolver_ztrtri_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYTF2 computes the factorization of a symmetric indefinite matrix \f$A\f$
  !>     using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A = U D U^T & \: \text{or}\newline
  !>
  !>         A = L D L^T &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U\f$ or \f$L\f$ is a product of permutation and unit upper/lower
  !>     triangular matrices (depending on the value of uplo), and \f$D\f$ is a symmetric
  !>     block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D(k)\f$.
  !> 
  !>     Specifically, \f$U\f$ and \f$L\f$ are computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U = P(n) U(n) \cdots P(k) U(k) \cdots & \: \text{and}\newline
  !>
  !>         L = P(1) L(1) \cdots P(k) L(k) \cdots &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2,
  !>     depending on the order of block \f$D(k)\f$, and \f$P(k)\f$ is a permutation matrix defined by
  !>     \f$ipiv[k]\f$. If we let \f$s\f$ denote the order of block \f$D(k)\f$, then \f$U(k)\f$
  !>     and \f$L(k)\f$ are unit upper/lower triangular matrices defined as
  !> 
  !>     \f[
  !>         U(k) = \left[ \begin{array}{ccc}
  !>         I_{k-s} & v & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & 0 & I_{n-k}
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     and
  !> 
  !>     \f[
  !>         L(k) = \left[ \begin{array}{ccc}
  !>         I_{k-1} & 0 & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & v & I_{n-k-s+1}
  !>         \end{array} \right].
  !>     \f]
  !> 
  !>     If \f$s = 1\f$, then \f$D(k)\f$ is stored in \f$A[k,k]\f$ and \f$v\f$ is stored in the upper/lower
  !>     part of column \f$k\f$ of \f$A\f$.
  !>     If \f$s = 2\f$ and uplo is upper, then \f$D(k)\f$ is stored in \f$A[k-1,k-1]\f$, \f$A[k-1,k]\f$,
  !>     and \f$A[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ of \f$A\f$.
  !>     If \f$s = 2\f$ and uplo is lower, then \f$D(k)\f$ is stored in \f$A[k,k]\f$, \f$A[k+1,k]\f$,
  !>     and \f$A[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and \f$k+1\f$ of \f$A\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrix A to be factored.
  !>               On exit, the block diagonal matrix D and the multipliers needed to
  !>               compute U or L.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= k <= n, if ipiv[k] > 0 then rows and columns k and ipiv[k]
  !>               were interchanged and D[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv[k] = ipiv[k-1] < 0 and uplo is upper (or ipiv[k]
  !>               = ipiv[k+1] < 0 and uplo is lower), then rows and columns k-1 and
  !>               -ipiv[k] (or rows and columns k+1 and -ipiv[k]) were interchanged
  !>               and D[k-1,k-1] to D[k,k] (or D[k,k] to D[k+1,k+1]) is a 2-by-2
  !>               diagonal block.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info[i] = j > 0, D is singular. D[j,j] is the first diagonal zero.
  interface rocsolver_ssytf2
    function rocsolver_ssytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_ssytf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytf2_full_rank,&
      rocsolver_ssytf2_rank_0,&
      rocsolver_ssytf2_rank_1
#endif
  end interface
  
  interface rocsolver_dsytf2
    function rocsolver_dsytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dsytf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytf2_full_rank,&
      rocsolver_dsytf2_rank_0,&
      rocsolver_dsytf2_rank_1
#endif
  end interface
  
  interface rocsolver_csytf2
    function rocsolver_csytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_csytf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csytf2_full_rank,&
      rocsolver_csytf2_rank_0,&
      rocsolver_csytf2_rank_1
#endif
  end interface
  
  interface rocsolver_zsytf2
    function rocsolver_zsytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zsytf2")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsytf2_full_rank,&
      rocsolver_zsytf2_rank_0,&
      rocsolver_zsytf2_rank_1
#endif
  end interface
  !>     \brief SYTF2_BATCHED computes the factorization of a batch of symmetric indefinite
  !>     matrices using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i D_i U_i^T & \: \text{or}\newline
  !>
  !>         A_i = L_i D_i L_i^T &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U_i\f$ or \f$L_i\f$ is a product of permutation and unit upper/lower
  !>     triangular matrices (depending on the value of uplo), and \f$D_i\f$ is a symmetric
  !>     block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_i(k)\f$.
  !> 
  !>     Specifically, \f$U_i\f$ and \f$L_i\f$ are computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i = P_i(n) U_i(n) \cdots P_i(k) U_i(k) \cdots & \: \text{and}\newline
  !>
  !>         L_i = P_i(1) L_i(1) \cdots P_i(k) L_i(k) \cdots &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2,
  !>     depending on the order of block \f$D_i(k)\f$, and \f$P_i(k)\f$ is a permutation matrix defined by
  !>     \f$ipiv_i[k]\f$. If we let \f$s\f$ denote the order of block \f$D_i(k)\f$, then \f$U_i(k)\f$
  !>     and \f$L_i(k)\f$ are unit upper/lower triangular matrices defined as
  !> 
  !>     \f[
  !>         U_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-s} & v & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & 0 & I_{n-k}
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     and
  !> 
  !>     \f[
  !>         L_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-1} & 0 & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & v & I_{n-k-s+1}
  !>         \end{array} \right].
  !>     \f]
  !> 
  !>     If \f$s = 1\f$, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$ and \f$v\f$ is stored in the upper/lower
  !>     part of column \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is upper, then \f$D_i(k)\f$ is stored in \f$A_i[k-1,k-1]\f$, \f$A_i[k-1,k]\f$,
  !>     and \f$A_i[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is lower, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$, \f$A_i[k+1,k]\f$,
  !>     and \f$A_i[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and \f$k+1\f$ of \f$A_i\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A_i is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrices A_i to be factored.
  !>               On exit, the block diagonal matrices D_i and the multipliers needed to
  !>               compute U_i or L_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= k <= n, if ipiv_i[k] > 0 then rows and columns k and ipiv_i[k]
  !>               were interchanged and D_i[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv_i[k] = ipiv_i[k-1] < 0 and uplo is upper (or ipiv_i[k]
  !>               = ipiv_i[k+1] < 0 and uplo is lower), then rows and columns k-1 and
  !>               -ipiv_i[k] (or rows and columns k+1 and -ipiv_i[k]) were interchanged
  !>               and D_i[k-1,k-1] to D_i[k,k] (or D_i[k,k] to D_i[k+1,k+1]) is a 2-by-2
  !>               diagonal block.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, D_i is singular. D_i[j,j] is the first diagonal zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_ssytf2_batched
    function rocsolver_ssytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_ssytf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytf2_batched_full_rank,&
      rocsolver_ssytf2_batched_rank_0,&
      rocsolver_ssytf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytf2_batched
    function rocsolver_dsytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dsytf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytf2_batched_full_rank,&
      rocsolver_dsytf2_batched_rank_0,&
      rocsolver_dsytf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_csytf2_batched
    function rocsolver_csytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_csytf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csytf2_batched_full_rank,&
      rocsolver_csytf2_batched_rank_0,&
      rocsolver_csytf2_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zsytf2_batched
    function rocsolver_zsytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zsytf2_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsytf2_batched_full_rank,&
      rocsolver_zsytf2_batched_rank_0,&
      rocsolver_zsytf2_batched_rank_1
#endif
  end interface
  !>     \brief SYTF2_STRIDED_BATCHED computes the factorization of a batch of symmetric indefinite
  !>     matrices using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     (This is the unblocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i D_i U_i^T & \: \text{or}\newline
  !>
  !>         A_i = L_i D_i L_i^T &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U_i\f$ or \f$L_i\f$ is a product of permutation and unit upper/lower
  !>     triangular matrices (depending on the value of uplo), and \f$D_i\f$ is a symmetric
  !>     block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_i(k)\f$.
  !> 
  !>     Specifically, \f$U_i\f$ and \f$L_i\f$ are computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i = P_i(n) U_i(n) \cdots P_i(k) U_i(k) \cdots & \: \text{and}\newline
  !>
  !>         L_i = P_i(1) L_i(1) \cdots P_i(k) L_i(k) \cdots &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2,
  !>     depending on the order of block \f$D_i(k)\f$, and \f$P_i(k)\f$ is a permutation matrix defined by
  !>     \f$ipiv_i[k]\f$. If we let \f$s\f$ denote the order of block \f$D_i(k)\f$, then \f$U_i(k)\f$
  !>     and \f$L_i(k)\f$ are unit upper/lower triangular matrices defined as
  !> 
  !>     \f[
  !>         U_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-s} & v & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & 0 & I_{n-k}
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     and
  !> 
  !>     \f[
  !>         L_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-1} & 0 & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & v & I_{n-k-s+1}
  !>         \end{array} \right].
  !>     \f]
  !> 
  !>     If \f$s = 1\f$, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$ and \f$v\f$ is stored in the upper/lower
  !>     part of column \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is upper, then \f$D_i(k)\f$ is stored in \f$A_i[k-1,k-1]\f$, \f$A_i[k-1,k]\f$,
  !>     and \f$A_i[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is lower, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$, \f$A_i[k+1,k]\f$,
  !>     and \f$A_i[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and \f$k+1\f$ of \f$A_i\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A_i is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the symmetric matrices A_i to be factored.
  !>               On exit, the block diagonal matrices D_i and the multipliers needed to
  !>               compute U_i or L_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= k <= n, if ipiv_i[k] > 0 then rows and columns k and ipiv_i[k]
  !>               were interchanged and D_i[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv_i[k] = ipiv_i[k-1] < 0 and uplo is upper (or ipiv_i[k]
  !>               = ipiv_i[k+1] < 0 and uplo is lower), then rows and columns k-1 and
  !>               -ipiv_i[k] (or rows and columns k+1 and -ipiv_i[k]) were interchanged
  !>               and D_i[k-1,k-1] to D_i[k,k] (or D_i[k,k] to D_i[k+1,k+1]) is a 2-by-2
  !>               diagonal block.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, D_i is singular. D_i[j,j] is the first diagonal zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_ssytf2_strided_batched
    function rocsolver_ssytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_ssytf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytf2_strided_batched_full_rank,&
      rocsolver_ssytf2_strided_batched_rank_0,&
      rocsolver_ssytf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytf2_strided_batched
    function rocsolver_dsytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dsytf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytf2_strided_batched_full_rank,&
      rocsolver_dsytf2_strided_batched_rank_0,&
      rocsolver_dsytf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_csytf2_strided_batched
    function rocsolver_csytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_csytf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csytf2_strided_batched_full_rank,&
      rocsolver_csytf2_strided_batched_rank_0,&
      rocsolver_csytf2_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zsytf2_strided_batched
    function rocsolver_zsytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zsytf2_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsytf2_strided_batched_full_rank,&
      rocsolver_zsytf2_strided_batched_rank_0,&
      rocsolver_zsytf2_strided_batched_rank_1
#endif
  end interface
  !>     \brief SYTRF computes the factorization of a symmetric indefinite matrix \f$A\f$
  !>     using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A = U D U^T & \: \text{or}\newline
  !>
  !>         A = L D L^T &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U\f$ or \f$L\f$ is a product of permutation and unit upper/lower
  !>     triangular matrices (depending on the value of uplo), and \f$D\f$ is a symmetric
  !>     block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D(k)\f$.
  !> 
  !>     Specifically, \f$U\f$ and \f$L\f$ are computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U = P(n) U(n) \cdots P(k) U(k) \cdots & \: \text{and}\newline
  !>
  !>         L = P(1) L(1) \cdots P(k) L(k) \cdots &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2,
  !>     depending on the order of block \f$D(k)\f$, and \f$P(k)\f$ is a permutation matrix defined by
  !>     \f$ipiv[k]\f$. If we let \f$s\f$ denote the order of block \f$D(k)\f$, then \f$U(k)\f$
  !>     and \f$L(k)\f$ are unit upper/lower triangular matrices defined as
  !> 
  !>     \f[
  !>         U(k) = \left[ \begin{array}{ccc}
  !>         I_{k-s} & v & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & 0 & I_{n-k}
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     and
  !> 
  !>     \f[
  !>         L(k) = \left[ \begin{array}{ccc}
  !>         I_{k-1} & 0 & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & v & I_{n-k-s+1}
  !>         \end{array} \right].
  !>     \f]
  !> 
  !>     If \f$s = 1\f$, then \f$D(k)\f$ is stored in \f$A[k,k]\f$ and \f$v\f$ is stored in the upper/lower
  !>     part of column \f$k\f$ of \f$A\f$.
  !>     If \f$s = 2\f$ and uplo is upper, then \f$D(k)\f$ is stored in \f$A[k-1,k-1]\f$, \f$A[k-1,k]\f$,
  !>     and \f$A[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ of \f$A\f$.
  !>     If \f$s = 2\f$ and uplo is lower, then \f$D(k)\f$ is stored in \f$A[k,k]\f$, \f$A[k+1,k]\f$,
  !>     and \f$A[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and \f$k+1\f$ of \f$A\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrix A is stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of the matrix A.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrix A to be factored.
  !>               On exit, the block diagonal matrix D and the multipliers needed to
  !>               compute U or L.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of A.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= k <= n, if ipiv[k] > 0 then rows and columns k and ipiv[k]
  !>               were interchanged and D[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv[k] = ipiv[k-1] < 0 and uplo is upper (or ipiv[k]
  !>               = ipiv[k+1] < 0 and uplo is lower), then rows and columns k-1 and
  !>               -ipiv[k] (or rows and columns k+1 and -ipiv[k]) were interchanged
  !>               and D[k-1,k-1] to D[k,k] (or D[k,k] to D[k+1,k+1]) is a 2-by-2
  !>               diagonal block.
  !>     @param[out]
  !>     info      pointer to a rocblas_int on the GPU.\n
  !>               If info = 0, successful exit.
  !>               If info[i] = j > 0, D is singular. D[j,j] is the first diagonal zero.
  interface rocsolver_ssytrf
    function rocsolver_ssytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_ssytrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytrf_full_rank,&
      rocsolver_ssytrf_rank_0,&
      rocsolver_ssytrf_rank_1
#endif
  end interface
  
  interface rocsolver_dsytrf
    function rocsolver_dsytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dsytrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytrf_full_rank,&
      rocsolver_dsytrf_rank_0,&
      rocsolver_dsytrf_rank_1
#endif
  end interface
  
  interface rocsolver_csytrf
    function rocsolver_csytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_csytrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csytrf_full_rank,&
      rocsolver_csytrf_rank_0,&
      rocsolver_csytrf_rank_1
#endif
  end interface
  
  interface rocsolver_zsytrf
    function rocsolver_zsytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zsytrf")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int) :: myInfo
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsytrf_full_rank,&
      rocsolver_zsytrf_rank_0,&
      rocsolver_zsytrf_rank_1
#endif
  end interface
  !>     \brief SYTRF_BATCHED computes the factorization of a batch of symmetric indefinite
  !>     matrices using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i D_i U_i^T & \: \text{or}\newline
  !>
  !>         A_i = L_i D_i L_i^T &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U_i\f$ or \f$L_i\f$ is a product of permutation and unit upper/lower
  !>     triangular matrices (depending on the value of uplo), and \f$D_i\f$ is a symmetric
  !>     block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_i(k)\f$.
  !> 
  !>     Specifically, \f$U_i\f$ and \f$L_i\f$ are computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i = P_i(n) U_i(n) \cdots P_i(k) U_i(k) \cdots & \: \text{and}\newline
  !>
  !>         L_i = P_i(1) L_i(1) \cdots P_i(k) L_i(k) \cdots &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2,
  !>     depending on the order of block \f$D_i(k)\f$, and \f$P_i(k)\f$ is a permutation matrix defined by
  !>     \f$ipiv_i[k]\f$. If we let \f$s\f$ denote the order of block \f$D_i(k)\f$, then \f$U_i(k)\f$
  !>     and \f$L_i(k)\f$ are unit upper/lower triangular matrices defined as
  !> 
  !>     \f[
  !>         U_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-s} & v & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & 0 & I_{n-k}
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     and
  !> 
  !>     \f[
  !>         L_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-1} & 0 & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & v & I_{n-k-s+1}
  !>         \end{array} \right].
  !>     \f]
  !> 
  !>     If \f$s = 1\f$, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$ and \f$v\f$ is stored in the upper/lower
  !>     part of column \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is upper, then \f$D_i(k)\f$ is stored in \f$A_i[k-1,k-1]\f$, \f$A_i[k-1,k]\f$,
  !>     and \f$A_i[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is lower, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$, \f$A_i[k+1,k]\f$,
  !>     and \f$A_i[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and \f$k+1\f$ of \f$A_i\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A_i is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.\n
  !>               On entry, the symmetric matrices A_i to be factored.
  !>               On exit, the block diagonal matrices D_i and the multipliers needed to
  !>               compute U_i or L_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= k <= n, if ipiv_i[k] > 0 then rows and columns k and ipiv_i[k]
  !>               were interchanged and D_i[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv_i[k] = ipiv_i[k-1] < 0 and uplo is upper (or ipiv_i[k]
  !>               = ipiv_i[k+1] < 0 and uplo is lower), then rows and columns k-1 and
  !>               -ipiv_i[k] (or rows and columns k+1 and -ipiv_i[k]) were interchanged
  !>               and D_i[k-1,k-1] to D_i[k,k] (or D_i[k,k] to D_i[k+1,k+1]) is a 2-by-2
  !>               diagonal block.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, D_i is singular. D_i[j,j] is the first diagonal zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_ssytrf_batched
    function rocsolver_ssytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_ssytrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytrf_batched_full_rank,&
      rocsolver_ssytrf_batched_rank_0,&
      rocsolver_ssytrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytrf_batched
    function rocsolver_dsytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dsytrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytrf_batched_full_rank,&
      rocsolver_dsytrf_batched_rank_0,&
      rocsolver_dsytrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_csytrf_batched
    function rocsolver_csytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_csytrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csytrf_batched_full_rank,&
      rocsolver_csytrf_batched_rank_0,&
      rocsolver_csytrf_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zsytrf_batched
    function rocsolver_zsytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zsytrf_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr) :: A
      integer(c_int),value :: lda
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsytrf_batched_full_rank,&
      rocsolver_zsytrf_batched_rank_0,&
      rocsolver_zsytrf_batched_rank_1
#endif
  end interface
  !>     \brief SYTRF_STRIDED_BATCHED computes the factorization of a batch of symmetric indefinite
  !>     matrices using Bunch-Kaufman diagonal pivoting.
  !> 
  !>     \details
  !>     (This is the blocked version of the algorithm).
  !> 
  !>     The factorization has the form
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         A_i = U_i D_i U_i^T & \: \text{or}\newline
  !>
  !>         A_i = L_i D_i L_i^T &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$U_i\f$ or \f$L_i\f$ is a product of permutation and unit upper/lower
  !>     triangular matrices (depending on the value of uplo), and \f$D_i\f$ is a symmetric
  !>     block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_i(k)\f$.
  !> 
  !>     Specifically, \f$U_i\f$ and \f$L_i\f$ are computed as
  !> 
  !>     \f[
  !>         \begin{array}{cl}
  !>         U_i = P_i(n) U_i(n) \cdots P_i(k) U_i(k) \cdots & \: \text{and}\newline
  !>
  !>         L_i = P_i(1) L_i(1) \cdots P_i(k) L_i(k) \cdots &
  !>         \end{array}
  !>     \f]
  !> 
  !>     where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2,
  !>     depending on the order of block \f$D_i(k)\f$, and \f$P_i(k)\f$ is a permutation matrix defined by
  !>     \f$ipiv_i[k]\f$. If we let \f$s\f$ denote the order of block \f$D_i(k)\f$, then \f$U_i(k)\f$
  !>     and \f$L_i(k)\f$ are unit upper/lower triangular matrices defined as
  !> 
  !>     \f[
  !>         U_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-s} & v & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & 0 & I_{n-k}
  !>         \end{array} \right]
  !>     \f]
  !> 
  !>     and
  !> 
  !>     \f[
  !>         L_i(k) = \left[ \begin{array}{ccc}
  !>         I_{k-1} & 0 & 0 \newline
  !>
  !>         0 & I_s & 0 \newline
  !>
  !>         0 & v & I_{n-k-s+1}
  !>         \end{array} \right].
  !>     \f]
  !> 
  !>     If \f$s = 1\f$, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$ and \f$v\f$ is stored in the upper/lower
  !>     part of column \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is upper, then \f$D_i(k)\f$ is stored in \f$A_i[k-1,k-1]\f$, \f$A_i[k-1,k]\f$,
  !>     and \f$A_i[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ of \f$A_i\f$.
  !>     If \f$s = 2\f$ and uplo is lower, then \f$D_i(k)\f$ is stored in \f$A_i[k,k]\f$, \f$A_i[k+1,k]\f$,
  !>     and \f$A_i[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and \f$k+1\f$ of \f$A_i\f$.
  !> 
  !>     @param[in]
  !>     handle    rocblas_handle.
  !>     @param[in]
  !>     uplo      rocblas_fill.\n
  !>               Specifies whether the upper or lower part of the matrices A_i are stored.
  !>               If uplo indicates lower (or upper), then the upper (or lower)
  !>               part of A_i is not used.
  !>     @param[in]
  !>     n         rocblas_int. n >= 0.\n
  !>               The number of rows and columns of all matrices A_i in the batch.
  !>     @param[inout]
  !>     A         pointer to type. Array on the GPU (the size depends on the value of strideA).\n
  !>               On entry, the symmetric matrices A_i to be factored.
  !>               On exit, the block diagonal matrices D_i and the multipliers needed to
  !>               compute U_i or L_i.
  !>     @param[in]
  !>     lda       rocblas_int. lda >= n.\n
  !>               Specifies the leading dimension of matrices A_i.
  !>     @param[in]
  !>     strideA   rocblas_stride.\n
  !>               Stride from the start of one matrix A_i to the next one A_(i+1).
  !>               There is no restriction for the value of strideA. Normal use case is strideA >= lda*n
  !>     @param[out]
  !>     ipiv      pointer to rocblas_int. Array on the GPU of dimension n.\n
  !>               The vector of pivot indices. Elements of ipiv are 1-based indices.
  !>               For 1 <= k <= n, if ipiv_i[k] > 0 then rows and columns k and ipiv_i[k]
  !>               were interchanged and D_i[k,k] is a 1-by-1 diagonal block.
  !>               If, instead, ipiv_i[k] = ipiv_i[k-1] < 0 and uplo is upper (or ipiv_i[k]
  !>               = ipiv_i[k+1] < 0 and uplo is lower), then rows and columns k-1 and
  !>               -ipiv_i[k] (or rows and columns k+1 and -ipiv_i[k]) were interchanged
  !>               and D_i[k-1,k-1] to D_i[k,k] (or D_i[k,k] to D_i[k+1,k+1]) is a 2-by-2
  !>               diagonal block.
  !>     @param[in]
  !>     strideP   rocblas_stride.\n
  !>               Stride from the start of one vector ipiv_i to the next one ipiv_(i+1).
  !>               There is no restriction for the value of strideP. Normal use case is strideP >= n.
  !>     @param[out]
  !>     info      pointer to rocblas_int. Array of batch_count integers on the GPU.\n
  !>               If info[i] = 0, successful exit for factorization of A_i.
  !>               If info[i] = j > 0, D_i is singular. D_i[j,j] is the first diagonal zero.
  !>     @param[in]
  !>     batch_count rocblas_int. batch_count >= 0.\n
  !>                 Number of matrices in the batch.
  interface rocsolver_ssytrf_strided_batched
    function rocsolver_ssytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_ssytrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_ssytrf_strided_batched_full_rank,&
      rocsolver_ssytrf_strided_batched_rank_0,&
      rocsolver_ssytrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_dsytrf_strided_batched
    function rocsolver_dsytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_dsytrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_dsytrf_strided_batched_full_rank,&
      rocsolver_dsytrf_strided_batched_rank_0,&
      rocsolver_dsytrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_csytrf_strided_batched
    function rocsolver_csytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_csytrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_csytrf_strided_batched_full_rank,&
      rocsolver_csytrf_strided_batched_rank_0,&
      rocsolver_csytrf_strided_batched_rank_1
#endif
  end interface
  
  interface rocsolver_zsytrf_strided_batched
    function rocsolver_zsytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count) bind(c, name="rocsolver_zsytrf_strided_batched")
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_
      type(c_ptr),value :: handle
      integer(kind(rocblas_fill_upper)),value :: uplo
      integer(c_int),value :: n
      type(c_ptr),value :: A
      integer(c_int),value :: lda
      integer(c_int64_t),value :: strideA
      type(c_ptr),value :: ipiv
      integer(c_int64_t),value :: strideP
      integer(c_int) :: myInfo
      integer(c_int),value :: batch_count
    end function

#ifdef USE_FPOINTER_INTERFACES
    module procedure &
      rocsolver_zsytrf_strided_batched_full_rank,&
      rocsolver_zsytrf_strided_batched_rank_0,&
      rocsolver_zsytrf_strided_batched_rank_1
#endif
  end interface

#ifdef USE_FPOINTER_INTERFACES
  contains
    function rocsolver_clacgv_rank_0(handle,n,x,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clacgv_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: x
      integer(c_int) :: incx
      !
      rocsolver_clacgv_rank_0 = rocsolver_clacgv_(handle,n,c_loc(x),incx)
    end function

    function rocsolver_clacgv_rank_1(handle,n,x,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clacgv_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      !
      rocsolver_clacgv_rank_1 = rocsolver_clacgv_(handle,n,c_loc(x),incx)
    end function

    function rocsolver_zlacgv_rank_0(handle,n,x,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: x
      integer(c_int) :: incx
      !
      rocsolver_zlacgv_rank_0 = rocsolver_zlacgv_(handle,n,c_loc(x),incx)
    end function

    function rocsolver_zlacgv_rank_1(handle,n,x,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      !
      rocsolver_zlacgv_rank_1 = rocsolver_zlacgv_(handle,n,c_loc(x),incx)
    end function

    function rocsolver_slaswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slaswp_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_slaswp_full_rank = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_slaswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slaswp_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_slaswp_rank_0 = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_slaswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slaswp_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_slaswp_rank_1 = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_dlaswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_dlaswp_full_rank = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_dlaswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_dlaswp_rank_0 = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_dlaswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_dlaswp_rank_1 = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_claswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_claswp_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_claswp_full_rank = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_claswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_claswp_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_claswp_rank_0 = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_claswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_claswp_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_claswp_rank_1 = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_zlaswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_zlaswp_full_rank = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_zlaswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_zlaswp_rank_0 = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_zlaswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: k1
      integer(c_int) :: k2
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: incx
      !
      rocsolver_zlaswp_rank_1 = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx)
    end function

    function rocsolver_slarfg_rank_0(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfg_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float) :: alpha
      real(c_float),target :: x
      integer(c_int) :: incx
      real(c_float) :: tau
      !
      rocsolver_slarfg_rank_0 = rocsolver_slarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_slarfg_rank_1(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfg_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float) :: alpha
      real(c_float),target,dimension(:) :: x
      integer(c_int) :: incx
      real(c_float) :: tau
      !
      rocsolver_slarfg_rank_1 = rocsolver_slarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_dlarfg_rank_0(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double) :: alpha
      real(c_double),target :: x
      integer(c_int) :: incx
      real(c_double) :: tau
      !
      rocsolver_dlarfg_rank_0 = rocsolver_dlarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_dlarfg_rank_1(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double) :: alpha
      real(c_double),target,dimension(:) :: x
      integer(c_int) :: incx
      real(c_double) :: tau
      !
      rocsolver_dlarfg_rank_1 = rocsolver_dlarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_clarfg_rank_0(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfg_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex) :: alpha
      complex(c_float_complex),target :: x
      integer(c_int) :: incx
      complex(c_float_complex) :: tau
      !
      rocsolver_clarfg_rank_0 = rocsolver_clarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_clarfg_rank_1(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfg_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex) :: alpha
      complex(c_float_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      complex(c_float_complex) :: tau
      !
      rocsolver_clarfg_rank_1 = rocsolver_clarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_zlarfg_rank_0(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex) :: alpha
      complex(c_double_complex),target :: x
      integer(c_int) :: incx
      complex(c_double_complex) :: tau
      !
      rocsolver_zlarfg_rank_0 = rocsolver_zlarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_zlarfg_rank_1(handle,n,alpha,x,incx,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex) :: alpha
      complex(c_double_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      complex(c_double_complex) :: tau
      !
      rocsolver_zlarfg_rank_1 = rocsolver_zlarfg_(handle,n,alpha,c_loc(x),incx,tau)
    end function

    function rocsolver_slarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarft_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_float) :: tau
      real(c_float),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_slarft_full_rank = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_slarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarft_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: V
      integer(c_int) :: ldv
      real(c_float) :: tau
      real(c_float),target :: T
      integer(c_int) :: ldt
      !
      rocsolver_slarft_rank_0 = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_slarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarft_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_float) :: tau
      real(c_float),target,dimension(:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_slarft_rank_1 = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_dlarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarft_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_double) :: tau
      real(c_double),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_dlarft_full_rank = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_dlarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarft_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: V
      integer(c_int) :: ldv
      real(c_double) :: tau
      real(c_double),target :: T
      integer(c_int) :: ldt
      !
      rocsolver_dlarft_rank_0 = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_dlarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarft_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_double) :: tau
      real(c_double),target,dimension(:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_dlarft_rank_1 = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_clarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarft_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      complex(c_float_complex) :: tau
      complex(c_float_complex),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_clarft_full_rank = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_clarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarft_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: V
      integer(c_int) :: ldv
      complex(c_float_complex) :: tau
      complex(c_float_complex),target :: T
      integer(c_int) :: ldt
      !
      rocsolver_clarft_rank_0 = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_clarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarft_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      complex(c_float_complex) :: tau
      complex(c_float_complex),target,dimension(:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_clarft_rank_1 = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_zlarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarft_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      complex(c_double_complex) :: tau
      complex(c_double_complex),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_zlarft_full_rank = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_zlarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarft_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: V
      integer(c_int) :: ldv
      complex(c_double_complex) :: tau
      complex(c_double_complex),target :: T
      integer(c_int) :: ldt
      !
      rocsolver_zlarft_rank_0 = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_zlarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarft_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      complex(c_double_complex) :: tau
      complex(c_double_complex),target,dimension(:) :: T
      integer(c_int) :: ldt
      !
      rocsolver_zlarft_rank_1 = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv,tau,c_loc(T),ldt)
    end function

    function rocsolver_slarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: x
      integer(c_int) :: incx
      real(c_float) :: alpha
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_slarf_full_rank = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_slarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: x
      integer(c_int) :: incx
      real(c_float) :: alpha
      real(c_float),target :: A
      integer(c_int) :: lda
      !
      rocsolver_slarf_rank_0 = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_slarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: x
      integer(c_int) :: incx
      real(c_float) :: alpha
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_slarf_rank_1 = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_dlarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: x
      integer(c_int) :: incx
      real(c_double) :: alpha
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_dlarf_full_rank = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_dlarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: x
      integer(c_int) :: incx
      real(c_double) :: alpha
      real(c_double),target :: A
      integer(c_int) :: lda
      !
      rocsolver_dlarf_rank_0 = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_dlarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: x
      integer(c_int) :: incx
      real(c_double) :: alpha
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_dlarf_rank_1 = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_clarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      complex(c_float_complex) :: alpha
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_clarf_full_rank = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_clarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: x
      integer(c_int) :: incx
      complex(c_float_complex) :: alpha
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      !
      rocsolver_clarf_rank_0 = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_clarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      complex(c_float_complex) :: alpha
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_clarf_rank_1 = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_zlarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      complex(c_double_complex) :: alpha
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_zlarf_full_rank = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_zlarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: x
      integer(c_int) :: incx
      complex(c_double_complex) :: alpha
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      !
      rocsolver_zlarf_rank_0 = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_zlarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: x
      integer(c_int) :: incx
      complex(c_double_complex) :: alpha
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_zlarf_rank_1 = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda)
    end function

    function rocsolver_slarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfb_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_slarfb_full_rank = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_slarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfb_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: V
      integer(c_int) :: ldv
      real(c_float),target :: T
      integer(c_int) :: ldt
      real(c_float),target :: A
      integer(c_int) :: lda
      !
      rocsolver_slarfb_rank_0 = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_slarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slarfb_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:) :: T
      integer(c_int) :: ldt
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_slarfb_rank_1 = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_dlarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_dlarfb_full_rank = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_dlarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: V
      integer(c_int) :: ldv
      real(c_double),target :: T
      integer(c_int) :: ldt
      real(c_double),target :: A
      integer(c_int) :: lda
      !
      rocsolver_dlarfb_rank_0 = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_dlarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:) :: T
      integer(c_int) :: ldt
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_dlarfb_rank_1 = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_clarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfb_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      complex(c_float_complex),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_clarfb_full_rank = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_clarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfb_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: V
      integer(c_int) :: ldv
      complex(c_float_complex),target :: T
      integer(c_int) :: ldt
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      !
      rocsolver_clarfb_rank_0 = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_clarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clarfb_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      complex(c_float_complex),target,dimension(:) :: T
      integer(c_int) :: ldt
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_clarfb_rank_1 = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_zlarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      complex(c_double_complex),target,dimension(:,:) :: T
      integer(c_int) :: ldt
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      !
      rocsolver_zlarfb_full_rank = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_zlarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: V
      integer(c_int) :: ldv
      complex(c_double_complex),target :: T
      integer(c_int) :: ldt
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      !
      rocsolver_zlarfb_rank_0 = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_zlarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(kind(rocblas_forward_direction)) :: myDirect
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      complex(c_double_complex),target,dimension(:) :: T
      integer(c_int) :: ldt
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      !
      rocsolver_zlarfb_rank_1 = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k,c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda)
    end function

    function rocsolver_slabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slabrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: tauq
      real(c_float),target,dimension(:) :: taup
      real(c_float),target,dimension(:,:) :: X
      integer(c_int) :: ldx
      real(c_float),target,dimension(:,:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_slabrd_full_rank = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_slabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slabrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float),target :: tauq
      real(c_float),target :: taup
      real(c_float),target :: X
      integer(c_int) :: ldx
      real(c_float),target :: Y
      integer(c_int) :: ldy
      !
      rocsolver_slabrd_rank_0 = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_slabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slabrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: tauq
      real(c_float),target,dimension(:) :: taup
      real(c_float),target,dimension(:) :: X
      integer(c_int) :: ldx
      real(c_float),target,dimension(:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_slabrd_rank_1 = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_dlabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: tauq
      real(c_double),target,dimension(:) :: taup
      real(c_double),target,dimension(:,:) :: X
      integer(c_int) :: ldx
      real(c_double),target,dimension(:,:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_dlabrd_full_rank = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_dlabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double),target :: tauq
      real(c_double),target :: taup
      real(c_double),target :: X
      integer(c_int) :: ldx
      real(c_double),target :: Y
      integer(c_int) :: ldy
      !
      rocsolver_dlabrd_rank_0 = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_dlabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: tauq
      real(c_double),target,dimension(:) :: taup
      real(c_double),target,dimension(:) :: X
      integer(c_int) :: ldx
      real(c_double),target,dimension(:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_dlabrd_rank_1 = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_clabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clabrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: tauq
      complex(c_float_complex),target,dimension(:) :: taup
      complex(c_float_complex),target,dimension(:,:) :: X
      integer(c_int) :: ldx
      complex(c_float_complex),target,dimension(:,:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_clabrd_full_rank = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_clabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clabrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex),target :: tauq
      complex(c_float_complex),target :: taup
      complex(c_float_complex),target :: X
      integer(c_int) :: ldx
      complex(c_float_complex),target :: Y
      integer(c_int) :: ldy
      !
      rocsolver_clabrd_rank_0 = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_clabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clabrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: tauq
      complex(c_float_complex),target,dimension(:) :: taup
      complex(c_float_complex),target,dimension(:) :: X
      integer(c_int) :: ldx
      complex(c_float_complex),target,dimension(:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_clabrd_rank_1 = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_zlabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: tauq
      complex(c_double_complex),target,dimension(:) :: taup
      complex(c_double_complex),target,dimension(:,:) :: X
      integer(c_int) :: ldx
      complex(c_double_complex),target,dimension(:,:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_zlabrd_full_rank = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_zlabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex),target :: tauq
      complex(c_double_complex),target :: taup
      complex(c_double_complex),target :: X
      integer(c_int) :: ldx
      complex(c_double_complex),target :: Y
      integer(c_int) :: ldy
      !
      rocsolver_zlabrd_rank_0 = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_zlabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: tauq
      complex(c_double_complex),target,dimension(:) :: taup
      complex(c_double_complex),target,dimension(:) :: X
      integer(c_int) :: ldx
      complex(c_double_complex),target,dimension(:) :: Y
      integer(c_int) :: ldy
      !
      rocsolver_zlabrd_rank_1 = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy)
    end function

    function rocsolver_slatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slatrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: E
      real(c_float) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_slatrd_full_rank = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_slatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slatrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: E
      real(c_float) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_slatrd_rank_0 = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_slatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slatrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: E
      real(c_float) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_slatrd_rank_1 = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_dlatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: E
      real(c_double) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_dlatrd_full_rank = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_dlatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: E
      real(c_double) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_dlatrd_rank_0 = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_dlatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: E
      real(c_double) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_dlatrd_rank_1 = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_clatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clatrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_clatrd_full_rank = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_clatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clatrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: E
      complex(c_float_complex) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_clatrd_rank_0 = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_clatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clatrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_clatrd_rank_1 = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_zlatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_zlatrd_full_rank = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_zlatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: E
      complex(c_double_complex) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_zlatrd_rank_0 = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_zlatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex) :: tau
      type(c_ptr) :: W
      integer(c_int) :: ldw
      !
      rocsolver_zlatrd_rank_1 = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E),tau,W,ldw)
    end function

    function rocsolver_slasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slasyf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_slasyf_full_rank = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_slasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slasyf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_slasyf_rank_0 = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_slasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_slasyf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_slasyf_rank_1 = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dlasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dlasyf_full_rank = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dlasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dlasyf_rank_0 = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dlasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dlasyf_rank_1 = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_clasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clasyf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_clasyf_full_rank = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_clasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clasyf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_clasyf_rank_0 = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_clasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_clasyf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_clasyf_rank_1 = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zlasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zlasyf_full_rank = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zlasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zlasyf_rank_0 = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zlasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nb
      type(c_ptr) :: kb
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zlasyf_rank_1 = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sorg2r_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorg2r_full_rank = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorg2r_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorg2r_rank_0 = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorg2r_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorg2r_rank_1 = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorg2r_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorg2r_full_rank = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorg2r_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorg2r_rank_0 = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorg2r_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorg2r_rank_1 = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cung2r_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2r_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cung2r_full_rank = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cung2r_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2r_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cung2r_rank_0 = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cung2r_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2r_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cung2r_rank_1 = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zung2r_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2r_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zung2r_full_rank = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zung2r_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2r_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zung2r_rank_0 = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zung2r_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2r_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zung2r_rank_1 = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgqr_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgqr_full_rank = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgqr_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorgqr_rank_0 = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgqr_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgqr_rank_1 = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgqr_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgqr_full_rank = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgqr_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorgqr_rank_0 = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgqr_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgqr_rank_1 = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungqr_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungqr_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungqr_full_rank = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungqr_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungqr_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cungqr_rank_0 = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungqr_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungqr_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungqr_rank_1 = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungqr_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungqr_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungqr_full_rank = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungqr_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungqr_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zungqr_rank_0 = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungqr_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungqr_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungqr_rank_1 = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgl2_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgl2_full_rank = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgl2_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorgl2_rank_0 = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgl2_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgl2_rank_1 = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgl2_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgl2_full_rank = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgl2_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorgl2_rank_0 = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgl2_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgl2_rank_1 = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungl2_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungl2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungl2_full_rank = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungl2_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungl2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cungl2_rank_0 = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungl2_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungl2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungl2_rank_1 = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungl2_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungl2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungl2_full_rank = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungl2_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungl2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zungl2_rank_0 = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungl2_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungl2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungl2_rank_1 = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorglq_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorglq_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorglq_full_rank = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorglq_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorglq_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorglq_rank_0 = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorglq_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorglq_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorglq_rank_1 = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorglq_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorglq_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorglq_full_rank = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorglq_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorglq_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorglq_rank_0 = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorglq_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorglq_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorglq_rank_1 = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cunglq_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunglq_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cunglq_full_rank = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cunglq_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunglq_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cunglq_rank_0 = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cunglq_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunglq_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cunglq_rank_1 = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zunglq_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunglq_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zunglq_full_rank = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zunglq_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunglq_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zunglq_rank_0 = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zunglq_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunglq_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zunglq_rank_1 = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorg2l_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorg2l_full_rank = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorg2l_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorg2l_rank_0 = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorg2l_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorg2l_rank_1 = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorg2l_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorg2l_full_rank = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorg2l_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorg2l_rank_0 = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorg2l_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorg2l_rank_1 = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cung2l_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2l_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cung2l_full_rank = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cung2l_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2l_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cung2l_rank_0 = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cung2l_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cung2l_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cung2l_rank_1 = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zung2l_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2l_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zung2l_full_rank = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zung2l_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2l_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zung2l_rank_0 = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zung2l_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zung2l_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zung2l_rank_1 = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgql_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgql_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgql_full_rank = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgql_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgql_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorgql_rank_0 = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgql_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgql_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgql_rank_1 = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgql_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgql_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgql_full_rank = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgql_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgql_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorgql_rank_0 = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgql_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgql_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgql_rank_1 = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungql_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungql_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungql_full_rank = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungql_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungql_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cungql_rank_0 = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungql_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungql_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungql_rank_1 = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungql_full_rank(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungql_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungql_full_rank = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungql_rank_0(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungql_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zungql_rank_0 = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungql_rank_1(handle,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungql_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungql_rank_1 = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgbr_full_rank(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgbr_full_rank = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgbr_rank_0(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorgbr_rank_0 = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgbr_rank_1(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgbr_rank_1 = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgbr_full_rank(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgbr_full_rank = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgbr_rank_0(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorgbr_rank_0 = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgbr_rank_1(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgbr_rank_1 = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungbr_full_rank(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungbr_full_rank = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungbr_rank_0(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cungbr_rank_0 = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungbr_rank_1(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungbr_rank_1 = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungbr_full_rank(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungbr_full_rank = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungbr_rank_0(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zungbr_rank_0 = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungbr_rank_1(handle,storev,m,n,k,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungbr_rank_1 = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgtr_full_rank(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgtr_full_rank = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgtr_rank_0(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sorgtr_rank_0 = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorgtr_rank_1(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sorgtr_rank_1 = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgtr_full_rank(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgtr_full_rank = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgtr_rank_0(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dorgtr_rank_0 = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dorgtr_rank_1(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dorgtr_rank_1 = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungtr_full_rank(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungtr_full_rank = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungtr_rank_0(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cungtr_rank_0 = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cungtr_rank_1(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cungtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cungtr_rank_1 = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungtr_full_rank(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungtr_full_rank = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungtr_rank_0(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zungtr_rank_0 = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zungtr_rank_1(handle,uplo,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zungtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zungtr_rank_1 = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sorm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorm2r_full_rank = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorm2r_rank_0 = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorm2r_rank_1 = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorm2r_full_rank = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorm2r_rank_0 = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorm2r_rank_1 = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunm2r_full_rank = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunm2r_rank_0 = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunm2r_rank_1 = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunm2r_full_rank = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunm2r_rank_0 = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunm2r_rank_1 = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormqr_full_rank = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormqr_rank_0 = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormqr_rank_1 = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormqr_full_rank = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormqr_rank_0 = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormqr_rank_1 = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmqr_full_rank = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmqr_rank_0 = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmqr_rank_1 = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmqr_full_rank = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmqr_rank_0 = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmqr_rank_1 = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorml2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorml2_full_rank = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorml2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorml2_rank_0 = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorml2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorml2_rank_1 = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorml2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorml2_full_rank = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorml2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorml2_rank_0 = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorml2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorml2_rank_1 = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunml2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunml2_full_rank = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunml2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunml2_rank_0 = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunml2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunml2_rank_1 = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunml2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunml2_full_rank = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunml2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunml2_rank_0 = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunml2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunml2_rank_1 = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormlq_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormlq_full_rank = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormlq_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormlq_rank_0 = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormlq_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormlq_rank_1 = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormlq_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormlq_full_rank = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormlq_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormlq_rank_0 = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormlq_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormlq_rank_1 = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmlq_full_rank = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmlq_rank_0 = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmlq_rank_1 = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmlq_full_rank = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmlq_rank_0 = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmlq_rank_1 = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorm2l_full_rank = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorm2l_rank_0 = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sorm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sorm2l_rank_1 = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorm2l_full_rank = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorm2l_rank_0 = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dorm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dorm2l_rank_1 = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunm2l_full_rank = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunm2l_rank_0 = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunm2l_rank_1 = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunm2l_full_rank = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunm2l_rank_0 = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunm2l_rank_1 = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormql_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormql_full_rank = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormql_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormql_rank_0 = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormql_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormql_rank_1 = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormql_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormql_full_rank = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormql_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormql_rank_0 = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormql_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormql_rank_1 = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmql_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmql_full_rank = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmql_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmql_rank_0 = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmql_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmql_rank_1 = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmql_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmql_full_rank = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmql_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmql_rank_0 = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmql_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmql_rank_1 = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormbr_full_rank = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormbr_rank_0 = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormbr_rank_1 = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormbr_full_rank = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormbr_rank_0 = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormbr_rank_1 = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmbr_full_rank = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmbr_rank_0 = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmbr_rank_1 = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmbr_full_rank = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmbr_rank_0 = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_column_wise)) :: storev
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: k
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmbr_rank_1 = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormtr_full_rank = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormtr_rank_0 = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sormtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sormtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_sormtr_rank_1 = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormtr_full_rank = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormtr_rank_0 = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_dormtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dormtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_dormtr_rank_1 = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmtr_full_rank = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmtr_rank_0 = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_cunmtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_cunmtr_rank_1 = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmtr_full_rank = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmtr_rank_0 = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_zunmtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_side_left)) :: side
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      !
      rocsolver_zunmtr_rank_1 = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc)
    end function

    function rocsolver_sbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sbdsqr_full_rank = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float),target :: V
      integer(c_int) :: ldv
      real(c_float),target :: U
      integer(c_int) :: ldu
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sbdsqr_rank_0 = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:) :: U
      integer(c_int) :: ldu
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sbdsqr_rank_1 = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dbdsqr_full_rank = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double),target :: V
      integer(c_int) :: ldv
      real(c_double),target :: U
      integer(c_int) :: ldu
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dbdsqr_rank_0 = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:) :: U
      integer(c_int) :: ldu
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dbdsqr_rank_1 = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      complex(c_float_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cbdsqr_full_rank = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex),target :: V
      integer(c_int) :: ldv
      complex(c_float_complex),target :: U
      integer(c_int) :: ldu
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cbdsqr_rank_0 = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      complex(c_float_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cbdsqr_rank_1 = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      complex(c_double_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zbdsqr_full_rank = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex),target :: V
      integer(c_int) :: ldv
      complex(c_double_complex),target :: U
      integer(c_int) :: ldu
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zbdsqr_rank_0 = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nv
      integer(c_int) :: nu
      integer(c_int) :: nc
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      complex(c_double_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zbdsqr_rank_1 = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E),c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_ssterf_rank_0(handle,n,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssterf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssterf_rank_0 = rocsolver_ssterf_(handle,n,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssterf_rank_1(handle,n,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssterf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssterf_rank_1 = rocsolver_ssterf_(handle,n,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsterf_rank_0(handle,n,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsterf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsterf_rank_0 = rocsolver_dsterf_(handle,n,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsterf_rank_1(handle,n,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsterf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsterf_rank_1 = rocsolver_dsterf_(handle,n,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_ssteqr_full_rank = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_ssteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_ssteqr_rank_0 = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_ssteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_ssteqr_rank_1 = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dsteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dsteqr_full_rank = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dsteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dsteqr_rank_0 = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dsteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dsteqr_rank_1 = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_csteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csteqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_csteqr_full_rank = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_csteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csteqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_csteqr_rank_0 = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_csteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csteqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_csteqr_rank_1 = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zsteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zsteqr_full_rank = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zsteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zsteqr_rank_0 = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zsteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zsteqr_rank_1 = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sstedc_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sstedc_full_rank = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sstedc_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sstedc_rank_0 = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sstedc_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sstedc_rank_1 = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dstedc_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dstedc_full_rank = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dstedc_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dstedc_rank_0 = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dstedc_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dstedc_rank_1 = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cstedc_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cstedc_full_rank = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cstedc_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cstedc_rank_0 = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cstedc_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cstedc_rank_1 = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zstedc_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zstedc_full_rank = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zstedc_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zstedc_rank_0 = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zstedc_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zstedc_rank_1 = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetf2_npvt_full_rank = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetf2_npvt_rank_0 = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetf2_npvt_rank_1 = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetf2_npvt_full_rank = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetf2_npvt_rank_0 = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetf2_npvt_rank_1 = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetf2_npvt_full_rank = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetf2_npvt_rank_0 = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetf2_npvt_rank_1 = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetf2_npvt_full_rank = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetf2_npvt_rank_0 = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetf2_npvt_rank_1 = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetf2_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_npvt_batched_full_rank = rocsolver_sgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_npvt_batched_rank_0 = rocsolver_sgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_npvt_batched_rank_1 = rocsolver_sgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_npvt_batched_full_rank = rocsolver_dgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_npvt_batched_rank_0 = rocsolver_dgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_npvt_batched_rank_1 = rocsolver_dgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_npvt_batched_full_rank = rocsolver_cgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_npvt_batched_rank_0 = rocsolver_cgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_npvt_batched_rank_1 = rocsolver_cgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_npvt_batched_full_rank = rocsolver_zgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_npvt_batched_rank_0 = rocsolver_zgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_npvt_batched_rank_1 = rocsolver_zgetf2_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_npvt_strided_batched_full_rank = rocsolver_sgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_npvt_strided_batched_rank_0 = rocsolver_sgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_npvt_strided_batched_rank_1 = rocsolver_sgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_npvt_strided_batched_full_rank = rocsolver_dgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_npvt_strided_batched_rank_0 = rocsolver_dgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_npvt_strided_batched_rank_1 = rocsolver_dgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_npvt_strided_batched_full_rank = rocsolver_cgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_npvt_strided_batched_rank_0 = rocsolver_cgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_npvt_strided_batched_rank_1 = rocsolver_cgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_npvt_strided_batched_full_rank = rocsolver_zgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_npvt_strided_batched_rank_0 = rocsolver_zgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_npvt_strided_batched_rank_1 = rocsolver_zgetf2_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetrf_npvt_full_rank = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetrf_npvt_rank_0 = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetrf_npvt_rank_1 = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetrf_npvt_full_rank = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetrf_npvt_rank_0 = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetrf_npvt_rank_1 = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetrf_npvt_full_rank = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetrf_npvt_rank_0 = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetrf_npvt_rank_1 = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetrf_npvt_full_rank = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetrf_npvt_rank_0 = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetrf_npvt_rank_1 = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetrf_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_npvt_batched_full_rank = rocsolver_sgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_npvt_batched_rank_0 = rocsolver_sgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_npvt_batched_rank_1 = rocsolver_sgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_npvt_batched_full_rank = rocsolver_dgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_npvt_batched_rank_0 = rocsolver_dgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_npvt_batched_rank_1 = rocsolver_dgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_npvt_batched_full_rank = rocsolver_cgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_npvt_batched_rank_0 = rocsolver_cgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_npvt_batched_rank_1 = rocsolver_cgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_npvt_batched_full_rank(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_npvt_batched_full_rank = rocsolver_zgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_npvt_batched_rank_0(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_npvt_batched_rank_0 = rocsolver_zgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_npvt_batched_rank_1(handle,m,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_npvt_batched_rank_1 = rocsolver_zgetrf_npvt_batched_(handle,m,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_npvt_strided_batched_full_rank = rocsolver_sgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_npvt_strided_batched_rank_0 = rocsolver_sgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_npvt_strided_batched_rank_1 = rocsolver_sgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_npvt_strided_batched_full_rank = rocsolver_dgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_npvt_strided_batched_rank_0 = rocsolver_dgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_npvt_strided_batched_rank_1 = rocsolver_dgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_npvt_strided_batched_full_rank = rocsolver_cgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_npvt_strided_batched_rank_0 = rocsolver_cgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_npvt_strided_batched_rank_1 = rocsolver_cgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_npvt_strided_batched_full_rank = rocsolver_zgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_npvt_strided_batched_rank_0 = rocsolver_zgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_npvt_strided_batched_rank_1 = rocsolver_zgetrf_npvt_strided_batched_(handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetf2_full_rank = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetf2_rank_0 = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetf2_rank_1 = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetf2_full_rank = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetf2_rank_0 = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetf2_rank_1 = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetf2_full_rank = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetf2_rank_0 = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetf2_rank_1 = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetf2_full_rank = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetf2_rank_0 = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetf2_rank_1 = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetf2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_batched_full_rank = rocsolver_sgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_batched_rank_0 = rocsolver_sgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_batched_rank_1 = rocsolver_sgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_batched_full_rank = rocsolver_dgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_batched_rank_0 = rocsolver_dgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_batched_rank_1 = rocsolver_dgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_batched_full_rank = rocsolver_cgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_batched_rank_0 = rocsolver_cgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_batched_rank_1 = rocsolver_cgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_batched_full_rank = rocsolver_zgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_batched_rank_0 = rocsolver_zgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_batched_rank_1 = rocsolver_zgetf2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_strided_batched_full_rank = rocsolver_sgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_strided_batched_rank_0 = rocsolver_sgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetf2_strided_batched_rank_1 = rocsolver_sgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_strided_batched_full_rank = rocsolver_dgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_strided_batched_rank_0 = rocsolver_dgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetf2_strided_batched_rank_1 = rocsolver_dgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_strided_batched_full_rank = rocsolver_cgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_strided_batched_rank_0 = rocsolver_cgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetf2_strided_batched_rank_1 = rocsolver_cgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_strided_batched_full_rank = rocsolver_zgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_strided_batched_rank_0 = rocsolver_zgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetf2_strided_batched_rank_1 = rocsolver_zgetf2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetrf_full_rank = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetrf_rank_0 = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetrf_rank_1 = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetrf_full_rank = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetrf_rank_0 = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetrf_rank_1 = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetrf_full_rank = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetrf_rank_0 = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetrf_rank_1 = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetrf_full_rank = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetrf_rank_0 = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetrf_rank_1 = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_batched_full_rank = rocsolver_sgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_batched_rank_0 = rocsolver_sgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_batched_rank_1 = rocsolver_sgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_batched_full_rank = rocsolver_dgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_batched_rank_0 = rocsolver_dgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_batched_rank_1 = rocsolver_dgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_batched_full_rank = rocsolver_cgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_batched_rank_0 = rocsolver_cgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_batched_rank_1 = rocsolver_cgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_batched_full_rank = rocsolver_zgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_batched_rank_0 = rocsolver_zgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_batched_rank_1 = rocsolver_zgetrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_strided_batched_full_rank = rocsolver_sgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_strided_batched_rank_0 = rocsolver_sgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrf_strided_batched_rank_1 = rocsolver_sgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_strided_batched_full_rank = rocsolver_dgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_strided_batched_rank_0 = rocsolver_dgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrf_strided_batched_rank_1 = rocsolver_dgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_strided_batched_full_rank = rocsolver_cgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_strided_batched_rank_0 = rocsolver_cgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrf_strided_batched_rank_1 = rocsolver_cgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_strided_batched_full_rank = rocsolver_zgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_strided_batched_rank_0 = rocsolver_zgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrf_strided_batched_rank_1 = rocsolver_zgetrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgeqr2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeqr2_full_rank = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqr2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgeqr2_rank_0 = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqr2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeqr2_rank_1 = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqr2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeqr2_full_rank = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqr2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgeqr2_rank_0 = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqr2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeqr2_rank_1 = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqr2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeqr2_full_rank = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqr2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgeqr2_rank_0 = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqr2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeqr2_rank_1 = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqr2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeqr2_full_rank = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqr2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgeqr2_rank_0 = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqr2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeqr2_rank_1 = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqr2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqr2_batched_full_rank = rocsolver_sgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqr2_batched_rank_0 = rocsolver_sgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqr2_batched_rank_1 = rocsolver_sgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqr2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqr2_batched_full_rank = rocsolver_dgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqr2_batched_rank_0 = rocsolver_dgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqr2_batched_rank_1 = rocsolver_dgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqr2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqr2_batched_full_rank = rocsolver_cgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqr2_batched_rank_0 = rocsolver_cgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqr2_batched_rank_1 = rocsolver_cgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqr2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqr2_batched_full_rank = rocsolver_zgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqr2_batched_rank_0 = rocsolver_zgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqr2_batched_rank_1 = rocsolver_zgeqr2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqr2_strided_batched_full_rank = rocsolver_sgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqr2_strided_batched_rank_0 = rocsolver_sgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqr2_strided_batched_rank_1 = rocsolver_sgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqr2_strided_batched_full_rank = rocsolver_dgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqr2_strided_batched_rank_0 = rocsolver_dgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqr2_strided_batched_rank_1 = rocsolver_dgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqr2_strided_batched_full_rank = rocsolver_cgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqr2_strided_batched_rank_0 = rocsolver_cgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqr2_strided_batched_rank_1 = rocsolver_cgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqr2_strided_batched_full_rank = rocsolver_zgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqr2_strided_batched_rank_0 = rocsolver_zgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqr2_strided_batched_rank_1 = rocsolver_zgeqr2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgerq2_full_rank = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgerq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgerq2_rank_0 = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgerq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgerq2_rank_1 = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgerq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgerq2_full_rank = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgerq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgerq2_rank_0 = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgerq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgerq2_rank_1 = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgerq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgerq2_full_rank = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgerq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgerq2_rank_0 = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgerq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgerq2_rank_1 = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgerq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgerq2_full_rank = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgerq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgerq2_rank_0 = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgerq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgerq2_rank_1 = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgerq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerq2_batched_full_rank = rocsolver_sgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerq2_batched_rank_0 = rocsolver_sgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerq2_batched_rank_1 = rocsolver_sgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerq2_batched_full_rank = rocsolver_dgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerq2_batched_rank_0 = rocsolver_dgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerq2_batched_rank_1 = rocsolver_dgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerq2_batched_full_rank = rocsolver_cgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerq2_batched_rank_0 = rocsolver_cgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerq2_batched_rank_1 = rocsolver_cgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerq2_batched_full_rank = rocsolver_zgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerq2_batched_rank_0 = rocsolver_zgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerq2_batched_rank_1 = rocsolver_zgerq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerq2_strided_batched_full_rank = rocsolver_sgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerq2_strided_batched_rank_0 = rocsolver_sgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerq2_strided_batched_rank_1 = rocsolver_sgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerq2_strided_batched_full_rank = rocsolver_dgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerq2_strided_batched_rank_0 = rocsolver_dgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerq2_strided_batched_rank_1 = rocsolver_dgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerq2_strided_batched_full_rank = rocsolver_cgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerq2_strided_batched_rank_0 = rocsolver_cgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerq2_strided_batched_rank_1 = rocsolver_cgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerq2_strided_batched_full_rank = rocsolver_zgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerq2_strided_batched_rank_0 = rocsolver_zgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerq2_strided_batched_rank_1 = rocsolver_zgerq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeql2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeql2_full_rank = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeql2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgeql2_rank_0 = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeql2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeql2_rank_1 = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeql2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeql2_full_rank = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeql2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgeql2_rank_0 = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeql2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeql2_rank_1 = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeql2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeql2_full_rank = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeql2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgeql2_rank_0 = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeql2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeql2_rank_1 = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeql2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeql2_full_rank = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeql2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgeql2_rank_0 = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeql2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeql2_rank_1 = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeql2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeql2_batched_full_rank = rocsolver_sgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeql2_batched_rank_0 = rocsolver_sgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeql2_batched_rank_1 = rocsolver_sgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeql2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeql2_batched_full_rank = rocsolver_dgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeql2_batched_rank_0 = rocsolver_dgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeql2_batched_rank_1 = rocsolver_dgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeql2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeql2_batched_full_rank = rocsolver_cgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeql2_batched_rank_0 = rocsolver_cgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeql2_batched_rank_1 = rocsolver_cgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeql2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeql2_batched_full_rank = rocsolver_zgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeql2_batched_rank_0 = rocsolver_zgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeql2_batched_rank_1 = rocsolver_zgeql2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeql2_strided_batched_full_rank = rocsolver_sgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeql2_strided_batched_rank_0 = rocsolver_sgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeql2_strided_batched_rank_1 = rocsolver_sgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeql2_strided_batched_full_rank = rocsolver_dgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeql2_strided_batched_rank_0 = rocsolver_dgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeql2_strided_batched_rank_1 = rocsolver_dgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeql2_strided_batched_full_rank = rocsolver_cgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeql2_strided_batched_rank_0 = rocsolver_cgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeql2_strided_batched_rank_1 = rocsolver_cgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeql2_strided_batched_full_rank = rocsolver_zgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeql2_strided_batched_rank_0 = rocsolver_zgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeql2_strided_batched_rank_1 = rocsolver_zgeql2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgelq2_full_rank = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgelq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgelq2_rank_0 = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgelq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgelq2_rank_1 = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgelq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgelq2_full_rank = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgelq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgelq2_rank_0 = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgelq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgelq2_rank_1 = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgelq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgelq2_full_rank = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgelq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgelq2_rank_0 = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgelq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgelq2_rank_1 = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgelq2_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgelq2_full_rank = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgelq2_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgelq2_rank_0 = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgelq2_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgelq2_rank_1 = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgelq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelq2_batched_full_rank = rocsolver_sgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelq2_batched_rank_0 = rocsolver_sgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelq2_batched_rank_1 = rocsolver_sgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelq2_batched_full_rank = rocsolver_dgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelq2_batched_rank_0 = rocsolver_dgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelq2_batched_rank_1 = rocsolver_dgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelq2_batched_full_rank = rocsolver_cgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelq2_batched_rank_0 = rocsolver_cgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelq2_batched_rank_1 = rocsolver_cgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelq2_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelq2_batched_full_rank = rocsolver_zgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelq2_batched_rank_0 = rocsolver_zgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelq2_batched_rank_1 = rocsolver_zgelq2_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelq2_strided_batched_full_rank = rocsolver_sgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelq2_strided_batched_rank_0 = rocsolver_sgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelq2_strided_batched_rank_1 = rocsolver_sgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelq2_strided_batched_full_rank = rocsolver_dgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelq2_strided_batched_rank_0 = rocsolver_dgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelq2_strided_batched_rank_1 = rocsolver_dgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelq2_strided_batched_full_rank = rocsolver_cgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelq2_strided_batched_rank_0 = rocsolver_cgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelq2_strided_batched_rank_1 = rocsolver_cgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelq2_strided_batched_full_rank = rocsolver_zgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelq2_strided_batched_rank_0 = rocsolver_zgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelq2_strided_batched_rank_1 = rocsolver_zgelq2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqrf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeqrf_full_rank = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqrf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgeqrf_rank_0 = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqrf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeqrf_rank_1 = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqrf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeqrf_full_rank = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqrf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgeqrf_rank_0 = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqrf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeqrf_rank_1 = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqrf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeqrf_full_rank = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqrf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgeqrf_rank_0 = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqrf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeqrf_rank_1 = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqrf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeqrf_full_rank = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqrf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgeqrf_rank_0 = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqrf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeqrf_rank_1 = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqrf_batched_full_rank = rocsolver_sgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqrf_batched_rank_0 = rocsolver_sgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqrf_batched_rank_1 = rocsolver_sgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqrf_batched_full_rank = rocsolver_dgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqrf_batched_rank_0 = rocsolver_dgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqrf_batched_rank_1 = rocsolver_dgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqrf_batched_full_rank = rocsolver_cgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqrf_batched_rank_0 = rocsolver_cgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqrf_batched_rank_1 = rocsolver_cgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqrf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqrf_batched_full_rank = rocsolver_zgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqrf_batched_rank_0 = rocsolver_zgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqrf_batched_rank_1 = rocsolver_zgeqrf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqrf_strided_batched_full_rank = rocsolver_sgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqrf_strided_batched_rank_0 = rocsolver_sgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqrf_strided_batched_rank_1 = rocsolver_sgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqrf_strided_batched_full_rank = rocsolver_dgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqrf_strided_batched_rank_0 = rocsolver_dgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqrf_strided_batched_rank_1 = rocsolver_dgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqrf_strided_batched_full_rank = rocsolver_cgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqrf_strided_batched_rank_0 = rocsolver_cgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqrf_strided_batched_rank_1 = rocsolver_cgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqrf_strided_batched_full_rank = rocsolver_zgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqrf_strided_batched_rank_0 = rocsolver_zgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqrf_strided_batched_rank_1 = rocsolver_zgeqrf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgerqf_full_rank = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgerqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgerqf_rank_0 = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgerqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgerqf_rank_1 = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgerqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgerqf_full_rank = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgerqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgerqf_rank_0 = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgerqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgerqf_rank_1 = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgerqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgerqf_full_rank = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgerqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgerqf_rank_0 = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgerqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgerqf_rank_1 = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgerqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgerqf_full_rank = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgerqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgerqf_rank_0 = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgerqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgerqf_rank_1 = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgerqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerqf_batched_full_rank = rocsolver_sgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerqf_batched_rank_0 = rocsolver_sgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerqf_batched_rank_1 = rocsolver_sgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerqf_batched_full_rank = rocsolver_dgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerqf_batched_rank_0 = rocsolver_dgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerqf_batched_rank_1 = rocsolver_dgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerqf_batched_full_rank = rocsolver_cgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerqf_batched_rank_0 = rocsolver_cgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerqf_batched_rank_1 = rocsolver_cgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerqf_batched_full_rank = rocsolver_zgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerqf_batched_rank_0 = rocsolver_zgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerqf_batched_rank_1 = rocsolver_zgerqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerqf_strided_batched_full_rank = rocsolver_sgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerqf_strided_batched_rank_0 = rocsolver_sgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgerqf_strided_batched_rank_1 = rocsolver_sgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerqf_strided_batched_full_rank = rocsolver_dgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerqf_strided_batched_rank_0 = rocsolver_dgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgerqf_strided_batched_rank_1 = rocsolver_dgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerqf_strided_batched_full_rank = rocsolver_cgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerqf_strided_batched_rank_0 = rocsolver_cgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgerqf_strided_batched_rank_1 = rocsolver_cgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerqf_strided_batched_full_rank = rocsolver_zgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerqf_strided_batched_rank_0 = rocsolver_zgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgerqf_strided_batched_rank_1 = rocsolver_zgerqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqlf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeqlf_full_rank = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqlf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgeqlf_rank_0 = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqlf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgeqlf_rank_1 = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqlf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeqlf_full_rank = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqlf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgeqlf_rank_0 = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgeqlf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgeqlf_rank_1 = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqlf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeqlf_full_rank = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqlf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgeqlf_rank_0 = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgeqlf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgeqlf_rank_1 = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqlf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeqlf_full_rank = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqlf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgeqlf_rank_0 = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgeqlf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgeqlf_rank_1 = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgeqlf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqlf_batched_full_rank = rocsolver_sgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqlf_batched_rank_0 = rocsolver_sgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqlf_batched_rank_1 = rocsolver_sgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqlf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqlf_batched_full_rank = rocsolver_dgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqlf_batched_rank_0 = rocsolver_dgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqlf_batched_rank_1 = rocsolver_dgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqlf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqlf_batched_full_rank = rocsolver_cgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqlf_batched_rank_0 = rocsolver_cgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqlf_batched_rank_1 = rocsolver_cgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqlf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqlf_batched_full_rank = rocsolver_zgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqlf_batched_rank_0 = rocsolver_zgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqlf_batched_rank_1 = rocsolver_zgeqlf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqlf_strided_batched_full_rank = rocsolver_sgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqlf_strided_batched_rank_0 = rocsolver_sgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgeqlf_strided_batched_rank_1 = rocsolver_sgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqlf_strided_batched_full_rank = rocsolver_dgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqlf_strided_batched_rank_0 = rocsolver_dgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgeqlf_strided_batched_rank_1 = rocsolver_dgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqlf_strided_batched_full_rank = rocsolver_cgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqlf_strided_batched_rank_0 = rocsolver_cgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgeqlf_strided_batched_rank_1 = rocsolver_cgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqlf_strided_batched_full_rank = rocsolver_zgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqlf_strided_batched_rank_0 = rocsolver_zgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgeqlf_strided_batched_rank_1 = rocsolver_zgeqlf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgelqf_full_rank = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgelqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      !
      rocsolver_sgelqf_rank_0 = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgelqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      !
      rocsolver_sgelqf_rank_1 = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgelqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgelqf_full_rank = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgelqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      !
      rocsolver_dgelqf_rank_0 = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_dgelqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      !
      rocsolver_dgelqf_rank_1 = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgelqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgelqf_full_rank = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgelqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      !
      rocsolver_cgelqf_rank_0 = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_cgelqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      !
      rocsolver_cgelqf_rank_1 = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgelqf_full_rank(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgelqf_full_rank = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgelqf_rank_0(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      !
      rocsolver_zgelqf_rank_0 = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_zgelqf_rank_1(handle,m,n,A,lda,ipiv)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      !
      rocsolver_zgelqf_rank_1 = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv))
    end function

    function rocsolver_sgelqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelqf_batched_full_rank = rocsolver_sgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelqf_batched_rank_0 = rocsolver_sgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelqf_batched_rank_1 = rocsolver_sgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelqf_batched_full_rank = rocsolver_dgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelqf_batched_rank_0 = rocsolver_dgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelqf_batched_rank_1 = rocsolver_dgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelqf_batched_full_rank = rocsolver_cgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelqf_batched_rank_0 = rocsolver_cgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelqf_batched_rank_1 = rocsolver_cgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelqf_batched_full_rank(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelqf_batched_full_rank = rocsolver_zgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelqf_batched_rank_0 = rocsolver_zgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelqf_batched_rank_1 = rocsolver_zgelqf_batched_(handle,m,n,c_loc(A),lda,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelqf_strided_batched_full_rank = rocsolver_sgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelqf_strided_batched_rank_0 = rocsolver_sgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgelqf_strided_batched_rank_1 = rocsolver_sgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelqf_strided_batched_full_rank = rocsolver_dgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelqf_strided_batched_rank_0 = rocsolver_dgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_dgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgelqf_strided_batched_rank_1 = rocsolver_dgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelqf_strided_batched_full_rank = rocsolver_cgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelqf_strided_batched_rank_0 = rocsolver_cgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_cgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgelqf_strided_batched_rank_1 = rocsolver_cgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelqf_strided_batched_full_rank = rocsolver_zgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelqf_strided_batched_rank_0 = rocsolver_zgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_zgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgelqf_strided_batched_rank_1 = rocsolver_zgelqf_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count)
    end function

    function rocsolver_sgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: tauq
      real(c_float),target,dimension(:) :: taup
      !
      rocsolver_sgebd2_full_rank = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_sgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float),target :: tauq
      real(c_float),target :: taup
      !
      rocsolver_sgebd2_rank_0 = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_sgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: tauq
      real(c_float),target,dimension(:) :: taup
      !
      rocsolver_sgebd2_rank_1 = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_dgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: tauq
      real(c_double),target,dimension(:) :: taup
      !
      rocsolver_dgebd2_full_rank = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_dgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double),target :: tauq
      real(c_double),target :: taup
      !
      rocsolver_dgebd2_rank_0 = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_dgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: tauq
      real(c_double),target,dimension(:) :: taup
      !
      rocsolver_dgebd2_rank_1 = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_cgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: tauq
      complex(c_float_complex),target,dimension(:) :: taup
      !
      rocsolver_cgebd2_full_rank = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_cgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex),target :: tauq
      complex(c_float_complex),target :: taup
      !
      rocsolver_cgebd2_rank_0 = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_cgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: tauq
      complex(c_float_complex),target,dimension(:) :: taup
      !
      rocsolver_cgebd2_rank_1 = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_zgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: tauq
      complex(c_double_complex),target,dimension(:) :: taup
      !
      rocsolver_zgebd2_full_rank = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_zgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex),target :: tauq
      complex(c_double_complex),target :: taup
      !
      rocsolver_zgebd2_rank_0 = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_zgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: tauq
      complex(c_double_complex),target,dimension(:) :: taup
      !
      rocsolver_zgebd2_rank_1 = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_sgebd2_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebd2_batched_full_rank = rocsolver_sgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebd2_batched_rank_0 = rocsolver_sgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebd2_batched_rank_1 = rocsolver_sgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebd2_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebd2_batched_full_rank = rocsolver_dgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebd2_batched_rank_0 = rocsolver_dgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebd2_batched_rank_1 = rocsolver_dgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebd2_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebd2_batched_full_rank = rocsolver_cgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebd2_batched_rank_0 = rocsolver_cgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebd2_batched_rank_1 = rocsolver_cgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebd2_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebd2_batched_full_rank = rocsolver_zgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebd2_batched_rank_0 = rocsolver_zgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebd2_batched_rank_1 = rocsolver_zgebd2_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebd2_strided_batched_full_rank = rocsolver_sgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebd2_strided_batched_rank_0 = rocsolver_sgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebd2_strided_batched_rank_1 = rocsolver_sgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebd2_strided_batched_full_rank = rocsolver_dgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebd2_strided_batched_rank_0 = rocsolver_dgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebd2_strided_batched_rank_1 = rocsolver_dgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebd2_strided_batched_full_rank = rocsolver_cgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebd2_strided_batched_rank_0 = rocsolver_cgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebd2_strided_batched_rank_1 = rocsolver_cgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebd2_strided_batched_full_rank = rocsolver_zgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebd2_strided_batched_rank_0 = rocsolver_zgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebd2_strided_batched_rank_1 = rocsolver_zgebd2_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: tauq
      real(c_float),target,dimension(:) :: taup
      !
      rocsolver_sgebrd_full_rank = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_sgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float),target :: tauq
      real(c_float),target :: taup
      !
      rocsolver_sgebrd_rank_0 = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_sgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float),target,dimension(:) :: tauq
      real(c_float),target,dimension(:) :: taup
      !
      rocsolver_sgebrd_rank_1 = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_dgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: tauq
      real(c_double),target,dimension(:) :: taup
      !
      rocsolver_dgebrd_full_rank = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_dgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double),target :: tauq
      real(c_double),target :: taup
      !
      rocsolver_dgebrd_rank_0 = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_dgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double),target,dimension(:) :: tauq
      real(c_double),target,dimension(:) :: taup
      !
      rocsolver_dgebrd_rank_1 = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_cgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: tauq
      complex(c_float_complex),target,dimension(:) :: taup
      !
      rocsolver_cgebrd_full_rank = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_cgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex),target :: tauq
      complex(c_float_complex),target :: taup
      !
      rocsolver_cgebrd_rank_0 = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_cgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex),target,dimension(:) :: tauq
      complex(c_float_complex),target,dimension(:) :: taup
      !
      rocsolver_cgebrd_rank_1 = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_zgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: tauq
      complex(c_double_complex),target,dimension(:) :: taup
      !
      rocsolver_zgebrd_full_rank = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_zgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex),target :: tauq
      complex(c_double_complex),target :: taup
      !
      rocsolver_zgebrd_rank_0 = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_zgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex),target,dimension(:) :: tauq
      complex(c_double_complex),target,dimension(:) :: taup
      !
      rocsolver_zgebrd_rank_1 = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E),c_loc(tauq),c_loc(taup))
    end function

    function rocsolver_sgebrd_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebrd_batched_full_rank = rocsolver_sgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebrd_batched_rank_0 = rocsolver_sgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebrd_batched_rank_1 = rocsolver_sgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebrd_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebrd_batched_full_rank = rocsolver_dgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebrd_batched_rank_0 = rocsolver_dgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebrd_batched_rank_1 = rocsolver_dgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebrd_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebrd_batched_full_rank = rocsolver_cgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebrd_batched_rank_0 = rocsolver_cgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebrd_batched_rank_1 = rocsolver_cgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebrd_batched_full_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebrd_batched_full_rank = rocsolver_zgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebrd_batched_rank_0 = rocsolver_zgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebrd_batched_rank_1 = rocsolver_zgebrd_batched_(handle,m,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebrd_strided_batched_full_rank = rocsolver_sgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebrd_strided_batched_rank_0 = rocsolver_sgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_float),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_sgebrd_strided_batched_rank_1 = rocsolver_sgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebrd_strided_batched_full_rank = rocsolver_dgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double),target :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebrd_strided_batched_rank_0 = rocsolver_dgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_dgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      real(c_double),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dgebrd_strided_batched_rank_1 = rocsolver_dgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebrd_strided_batched_full_rank = rocsolver_cgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebrd_strided_batched_rank_0 = rocsolver_cgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_cgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_float_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_cgebrd_strided_batched_rank_1 = rocsolver_cgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebrd_strided_batched_full_rank = rocsolver_zgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebrd_strided_batched_rank_0 = rocsolver_zgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_zgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq,strideQ,taup,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex),target,dimension(:) :: tauq
      integer(c_int64_t) :: strideQ
      complex(c_double_complex),target,dimension(:) :: taup
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zgebrd_strided_batched_rank_1 = rocsolver_zgebrd_strided_batched_(handle,m,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count)
    end function

    function rocsolver_sgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_sgetrs_full_rank = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_sgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      real(c_float),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_sgetrs_rank_0 = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_sgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_sgetrs_rank_1 = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_dgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dgetrs_full_rank = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_dgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      real(c_double),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_dgetrs_rank_0 = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_dgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dgetrs_rank_1 = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_cgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_cgetrs_full_rank = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_cgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_cgetrs_rank_0 = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_cgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_cgetrs_rank_1 = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_zgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zgetrs_full_rank = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_zgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_zgetrs_rank_0 = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_zgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zgetrs_rank_1 = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb)
    end function

    function rocsolver_sgetrs_batched_full_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrs_batched_full_rank = rocsolver_sgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_sgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrs_batched_rank_0 = rocsolver_sgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_sgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrs_batched_rank_1 = rocsolver_sgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dgetrs_batched_full_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrs_batched_full_rank = rocsolver_dgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrs_batched_rank_0 = rocsolver_dgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrs_batched_rank_1 = rocsolver_dgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_cgetrs_batched_full_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrs_batched_full_rank = rocsolver_cgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_cgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrs_batched_rank_0 = rocsolver_cgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_cgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrs_batched_rank_1 = rocsolver_cgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zgetrs_batched_full_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrs_batched_full_rank = rocsolver_zgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrs_batched_rank_0 = rocsolver_zgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrs_batched_rank_1 = rocsolver_zgetrs_batched_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_sgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrs_strided_batched_full_rank = rocsolver_sgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_sgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrs_strided_batched_rank_0 = rocsolver_sgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_sgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_sgetrs_strided_batched_rank_1 = rocsolver_sgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrs_strided_batched_full_rank = rocsolver_dgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrs_strided_batched_rank_0 = rocsolver_dgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dgetrs_strided_batched_rank_1 = rocsolver_dgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_cgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrs_strided_batched_full_rank = rocsolver_cgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_cgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrs_strided_batched_rank_0 = rocsolver_cgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_cgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_cgetrs_strided_batched_rank_1 = rocsolver_cgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrs_strided_batched_full_rank = rocsolver_zgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrs_strided_batched_rank_0 = rocsolver_zgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zgetrs_strided_batched_rank_1 = rocsolver_zgetrs_strided_batched_(handle,trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_sgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sgesv_full_rank = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sgesv_rank_0 = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sgesv_rank_1 = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dgesv_full_rank = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dgesv_rank_0 = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dgesv_rank_1 = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cgesv_full_rank = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cgesv_rank_0 = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cgesv_rank_1 = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zgesv_full_rank = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zgesv_rank_0 = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zgesv_rank_1 = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sgesv_batched_full_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesv_batched_full_rank = rocsolver_sgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesv_batched_rank_0 = rocsolver_sgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesv_batched_rank_1 = rocsolver_sgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dgesv_batched_full_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesv_batched_full_rank = rocsolver_dgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesv_batched_rank_0 = rocsolver_dgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesv_batched_rank_1 = rocsolver_dgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cgesv_batched_full_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesv_batched_full_rank = rocsolver_cgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesv_batched_rank_0 = rocsolver_cgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesv_batched_rank_1 = rocsolver_cgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zgesv_batched_full_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesv_batched_full_rank = rocsolver_zgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesv_batched_rank_0 = rocsolver_zgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesv_batched_rank_1 = rocsolver_zgesv_batched_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesv_strided_batched_full_rank = rocsolver_sgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesv_strided_batched_rank_0 = rocsolver_sgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesv_strided_batched_rank_1 = rocsolver_sgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesv_strided_batched_full_rank = rocsolver_dgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesv_strided_batched_rank_0 = rocsolver_dgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesv_strided_batched_rank_1 = rocsolver_dgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesv_strided_batched_full_rank = rocsolver_cgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesv_strided_batched_rank_0 = rocsolver_cgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesv_strided_batched_rank_1 = rocsolver_cgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesv_strided_batched_full_rank = rocsolver_zgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesv_strided_batched_rank_0 = rocsolver_zgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesv_strided_batched_rank_1 = rocsolver_zgesv_strided_batched_(handle,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sgetri_full_rank(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_full_rank = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetri_rank_0(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_rank_0 = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetri_rank_1(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_rank_1 = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetri_full_rank(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_full_rank = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetri_rank_0(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_rank_0 = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dgetri_rank_1(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_rank_1 = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetri_full_rank(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_full_rank = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetri_rank_0(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_rank_0 = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_cgetri_rank_1(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_rank_1 = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetri_full_rank(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_full_rank = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetri_rank_0(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_rank_0 = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zgetri_rank_1(handle,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_rank_1 = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_sgetri_batched_full_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_batched_full_rank = rocsolver_sgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_batched_rank_0 = rocsolver_sgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_batched_rank_1 = rocsolver_sgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetri_batched_full_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_batched_full_rank = rocsolver_dgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_batched_rank_0 = rocsolver_dgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_batched_rank_1 = rocsolver_dgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetri_batched_full_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_batched_full_rank = rocsolver_cgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_batched_rank_0 = rocsolver_cgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_batched_rank_1 = rocsolver_cgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetri_batched_full_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_batched_full_rank = rocsolver_zgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_batched_rank_0 = rocsolver_zgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_batched_rank_1 = rocsolver_zgetri_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_strided_batched_full_rank = rocsolver_sgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_strided_batched_rank_0 = rocsolver_sgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_strided_batched_rank_1 = rocsolver_sgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_strided_batched_full_rank = rocsolver_dgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_strided_batched_rank_0 = rocsolver_dgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_strided_batched_rank_1 = rocsolver_dgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_strided_batched_full_rank = rocsolver_cgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_strided_batched_rank_0 = rocsolver_cgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_cgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_strided_batched_rank_1 = rocsolver_cgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_strided_batched_full_rank = rocsolver_zgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_strided_batched_rank_0 = rocsolver_zgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_strided_batched_rank_1 = rocsolver_zgetri_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_full_rank(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_npvt_full_rank = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetri_npvt_rank_0(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_npvt_rank_0 = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetri_npvt_rank_1(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_npvt_rank_1 = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetri_npvt_full_rank(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_npvt_full_rank = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetri_npvt_rank_0(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_npvt_rank_0 = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dgetri_npvt_rank_1(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_npvt_rank_1 = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetri_npvt_full_rank(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_npvt_full_rank = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetri_npvt_rank_0(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_npvt_rank_0 = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cgetri_npvt_rank_1(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_npvt_rank_1 = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetri_npvt_full_rank(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_npvt_full_rank = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetri_npvt_rank_0(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_npvt_rank_0 = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zgetri_npvt_rank_1(handle,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_npvt_rank_1 = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_sgetri_npvt_batched_full_rank(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_batched_full_rank = rocsolver_sgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_batched_rank_0(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_batched_rank_0 = rocsolver_sgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_batched_rank_1(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_batched_rank_1 = rocsolver_sgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_batched_full_rank(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_batched_full_rank = rocsolver_dgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_batched_rank_0(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_batched_rank_0 = rocsolver_dgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_batched_rank_1(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_batched_rank_1 = rocsolver_dgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_batched_full_rank(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_batched_full_rank = rocsolver_cgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_batched_rank_0(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_batched_rank_0 = rocsolver_cgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_batched_rank_1(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_batched_rank_1 = rocsolver_cgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_batched_full_rank(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_batched_full_rank = rocsolver_zgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_batched_rank_0(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_batched_rank_0 = rocsolver_zgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_batched_rank_1(handle,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_batched_rank_1 = rocsolver_zgetri_npvt_batched_(handle,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_strided_batched_full_rank = rocsolver_sgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_strided_batched_rank_0 = rocsolver_sgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_strided_batched_rank_1 = rocsolver_sgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_strided_batched_full_rank = rocsolver_dgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_strided_batched_rank_0 = rocsolver_dgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_strided_batched_rank_1 = rocsolver_dgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_strided_batched_full_rank = rocsolver_cgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_strided_batched_rank_0 = rocsolver_cgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_strided_batched_rank_1 = rocsolver_cgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_strided_batched_full_rank = rocsolver_zgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_strided_batched_rank_0 = rocsolver_zgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_strided_batched_rank_1 = rocsolver_zgetri_npvt_strided_batched_(handle,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sgels_full_rank = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sgels_rank_0 = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sgels_rank_1 = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dgels_full_rank = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dgels_rank_0 = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dgels_rank_1 = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cgels_full_rank = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cgels_rank_0 = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cgels_rank_1 = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zgels_full_rank = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zgels_rank_0 = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zgels_rank_1 = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sgels_batched_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgels_batched_full_rank = rocsolver_sgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sgels_batched_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgels_batched_rank_0 = rocsolver_sgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sgels_batched_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgels_batched_rank_1 = rocsolver_sgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dgels_batched_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgels_batched_full_rank = rocsolver_dgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dgels_batched_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgels_batched_rank_0 = rocsolver_dgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dgels_batched_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgels_batched_rank_1 = rocsolver_dgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cgels_batched_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgels_batched_full_rank = rocsolver_cgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cgels_batched_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgels_batched_rank_0 = rocsolver_cgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cgels_batched_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgels_batched_rank_1 = rocsolver_cgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zgels_batched_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgels_batched_full_rank = rocsolver_zgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zgels_batched_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgels_batched_rank_0 = rocsolver_zgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zgels_batched_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgels_batched_rank_1 = rocsolver_zgels_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgels_strided_batched_full_rank = rocsolver_sgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgels_strided_batched_rank_0 = rocsolver_sgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgels_strided_batched_rank_1 = rocsolver_sgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgels_strided_batched_full_rank = rocsolver_dgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgels_strided_batched_rank_0 = rocsolver_dgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgels_strided_batched_rank_1 = rocsolver_dgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgels_strided_batched_full_rank = rocsolver_cgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgels_strided_batched_rank_0 = rocsolver_cgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgels_strided_batched_rank_1 = rocsolver_cgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgels_strided_batched_full_rank = rocsolver_zgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgels_strided_batched_rank_0 = rocsolver_zgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_operation_none)) :: trans
      integer(c_int) :: m
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgels_strided_batched_rank_1 = rocsolver_zgels_strided_batched_(handle,trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_spotf2_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotf2_full_rank = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotf2_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotf2_rank_0 = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotf2_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotf2_rank_1 = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotf2_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotf2_full_rank = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotf2_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotf2_rank_0 = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotf2_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotf2_rank_1 = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotf2_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotf2_full_rank = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotf2_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotf2_rank_0 = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotf2_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotf2_rank_1 = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotf2_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotf2_full_rank = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotf2_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotf2_rank_0 = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotf2_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotf2_rank_1 = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotf2_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotf2_batched_full_rank = rocsolver_spotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotf2_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotf2_batched_rank_0 = rocsolver_spotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotf2_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotf2_batched_rank_1 = rocsolver_spotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotf2_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotf2_batched_full_rank = rocsolver_dpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotf2_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotf2_batched_rank_0 = rocsolver_dpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotf2_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotf2_batched_rank_1 = rocsolver_dpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotf2_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotf2_batched_full_rank = rocsolver_cpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotf2_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotf2_batched_rank_0 = rocsolver_cpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotf2_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotf2_batched_rank_1 = rocsolver_cpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotf2_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotf2_batched_full_rank = rocsolver_zpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotf2_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotf2_batched_rank_0 = rocsolver_zpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotf2_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotf2_batched_rank_1 = rocsolver_zpotf2_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotf2_strided_batched_full_rank = rocsolver_spotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotf2_strided_batched_rank_0 = rocsolver_spotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotf2_strided_batched_rank_1 = rocsolver_spotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotf2_strided_batched_full_rank = rocsolver_dpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotf2_strided_batched_rank_0 = rocsolver_dpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotf2_strided_batched_rank_1 = rocsolver_dpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotf2_strided_batched_full_rank = rocsolver_cpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotf2_strided_batched_rank_0 = rocsolver_cpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotf2_strided_batched_rank_1 = rocsolver_cpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotf2_strided_batched_full_rank = rocsolver_zpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotf2_strided_batched_rank_0 = rocsolver_zpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotf2_strided_batched_rank_1 = rocsolver_zpotf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotrf_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotrf_full_rank = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotrf_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotrf_rank_0 = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotrf_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotrf_rank_1 = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotrf_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotrf_full_rank = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotrf_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotrf_rank_0 = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotrf_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotrf_rank_1 = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotrf_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotrf_full_rank = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotrf_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotrf_rank_0 = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotrf_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotrf_rank_1 = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotrf_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotrf_full_rank = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotrf_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotrf_rank_0 = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotrf_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotrf_rank_1 = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotrf_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotrf_batched_full_rank = rocsolver_spotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotrf_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotrf_batched_rank_0 = rocsolver_spotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotrf_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotrf_batched_rank_1 = rocsolver_spotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotrf_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrf_batched_full_rank = rocsolver_dpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotrf_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrf_batched_rank_0 = rocsolver_dpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotrf_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrf_batched_rank_1 = rocsolver_dpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotrf_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrf_batched_full_rank = rocsolver_cpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotrf_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrf_batched_rank_0 = rocsolver_cpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotrf_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrf_batched_rank_1 = rocsolver_cpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotrf_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrf_batched_full_rank = rocsolver_zpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotrf_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrf_batched_rank_0 = rocsolver_zpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotrf_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrf_batched_rank_1 = rocsolver_zpotrf_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotrf_strided_batched_full_rank = rocsolver_spotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotrf_strided_batched_rank_0 = rocsolver_spotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotrf_strided_batched_rank_1 = rocsolver_spotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrf_strided_batched_full_rank = rocsolver_dpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrf_strided_batched_rank_0 = rocsolver_dpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrf_strided_batched_rank_1 = rocsolver_dpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrf_strided_batched_full_rank = rocsolver_cpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrf_strided_batched_rank_0 = rocsolver_cpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrf_strided_batched_rank_1 = rocsolver_cpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrf_strided_batched_full_rank = rocsolver_zpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrf_strided_batched_rank_0 = rocsolver_zpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrf_strided_batched_rank_1 = rocsolver_zpotrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_spotrs_full_rank = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_spotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_spotrs_rank_0 = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_spotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_spotrs_rank_1 = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dpotrs_full_rank = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_dpotrs_rank_0 = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dpotrs_rank_1 = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_cpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_cpotrs_full_rank = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_cpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_cpotrs_rank_0 = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_cpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_cpotrs_rank_1 = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zpotrs_full_rank = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_zpotrs_rank_0 = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zpotrs_rank_1 = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_spotrs_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_spotrs_batched_full_rank = rocsolver_spotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_spotrs_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_spotrs_batched_rank_0 = rocsolver_spotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_spotrs_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_spotrs_batched_rank_1 = rocsolver_spotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dpotrs_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrs_batched_full_rank = rocsolver_dpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dpotrs_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrs_batched_rank_0 = rocsolver_dpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dpotrs_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrs_batched_rank_1 = rocsolver_dpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_cpotrs_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrs_batched_full_rank = rocsolver_cpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_cpotrs_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrs_batched_rank_0 = rocsolver_cpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_cpotrs_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrs_batched_rank_1 = rocsolver_cpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zpotrs_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrs_batched_full_rank = rocsolver_zpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zpotrs_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrs_batched_rank_0 = rocsolver_zpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zpotrs_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrs_batched_rank_1 = rocsolver_zpotrs_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_spotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_spotrs_strided_batched_full_rank = rocsolver_spotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_spotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_spotrs_strided_batched_rank_0 = rocsolver_spotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_spotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_spotrs_strided_batched_rank_1 = rocsolver_spotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dpotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrs_strided_batched_full_rank = rocsolver_dpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dpotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrs_strided_batched_rank_0 = rocsolver_dpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dpotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dpotrs_strided_batched_rank_1 = rocsolver_dpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_cpotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrs_strided_batched_full_rank = rocsolver_cpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_cpotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrs_strided_batched_rank_0 = rocsolver_cpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_cpotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_cpotrs_strided_batched_rank_1 = rocsolver_cpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zpotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrs_strided_batched_full_rank = rocsolver_zpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zpotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrs_strided_batched_rank_0 = rocsolver_zpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zpotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zpotrs_strided_batched_rank_1 = rocsolver_zpotrs_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_sposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sposv_full_rank = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sposv_rank_0 = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_sposv_rank_1 = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dposv_full_rank = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dposv_rank_0 = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_dposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_dposv_rank_1 = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cposv_full_rank = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cposv_rank_0 = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_cposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_cposv_rank_1 = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zposv_full_rank = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zposv_rank_0 = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_zposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      !
      rocsolver_zposv_rank_1 = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo)
    end function

    function rocsolver_sposv_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sposv_batched_full_rank = rocsolver_sposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sposv_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sposv_batched_rank_0 = rocsolver_sposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sposv_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sposv_batched_rank_1 = rocsolver_sposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dposv_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dposv_batched_full_rank = rocsolver_dposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dposv_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dposv_batched_rank_0 = rocsolver_dposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_dposv_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dposv_batched_rank_1 = rocsolver_dposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cposv_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cposv_batched_full_rank = rocsolver_cposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cposv_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cposv_batched_rank_0 = rocsolver_cposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_cposv_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cposv_batched_rank_1 = rocsolver_cposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zposv_batched_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zposv_batched_full_rank = rocsolver_zposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zposv_batched_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zposv_batched_rank_0 = rocsolver_zposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_zposv_batched_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zposv_batched_rank_1 = rocsolver_zposv_batched_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo,batch_count)
    end function

    function rocsolver_sposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sposv_strided_batched_full_rank = rocsolver_sposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sposv_strided_batched_rank_0 = rocsolver_sposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_sposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sposv_strided_batched_rank_1 = rocsolver_sposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dposv_strided_batched_full_rank = rocsolver_dposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dposv_strided_batched_rank_0 = rocsolver_dposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_dposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dposv_strided_batched_rank_1 = rocsolver_dposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cposv_strided_batched_full_rank = rocsolver_cposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cposv_strided_batched_rank_0 = rocsolver_cposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_cposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cposv_strided_batched_rank_1 = rocsolver_cposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zposv_strided_batched_full_rank = rocsolver_zposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zposv_strided_batched_rank_0 = rocsolver_zposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_zposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      integer(c_int) :: nrhs
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zposv_strided_batched_rank_1 = rocsolver_zposv_strided_batched_(handle,uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count)
    end function

    function rocsolver_spotri_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotri_full_rank = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotri_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotri_rank_0 = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotri_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_spotri_rank_1 = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotri_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotri_full_rank = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotri_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotri_rank_0 = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dpotri_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dpotri_rank_1 = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotri_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotri_full_rank = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotri_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotri_rank_0 = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_cpotri_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_cpotri_rank_1 = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotri_full_rank(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotri_full_rank = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotri_rank_0(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotri_rank_0 = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_zpotri_rank_1(handle,uplo,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_zpotri_rank_1 = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_spotri_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotri_batched_full_rank = rocsolver_spotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotri_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotri_batched_rank_0 = rocsolver_spotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotri_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotri_batched_rank_1 = rocsolver_spotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotri_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotri_batched_full_rank = rocsolver_dpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotri_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotri_batched_rank_0 = rocsolver_dpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dpotri_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotri_batched_rank_1 = rocsolver_dpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotri_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotri_batched_full_rank = rocsolver_cpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotri_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotri_batched_rank_0 = rocsolver_cpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_cpotri_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotri_batched_rank_1 = rocsolver_cpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotri_batched_full_rank(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotri_batched_full_rank = rocsolver_zpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotri_batched_rank_0(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotri_batched_rank_0 = rocsolver_zpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_zpotri_batched_rank_1(handle,uplo,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotri_batched_rank_1 = rocsolver_zpotri_batched_(handle,uplo,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_spotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotri_strided_batched_full_rank = rocsolver_spotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotri_strided_batched_rank_0 = rocsolver_spotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_spotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_spotri_strided_batched_rank_1 = rocsolver_spotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotri_strided_batched_full_rank = rocsolver_dpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotri_strided_batched_rank_0 = rocsolver_dpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dpotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dpotri_strided_batched_rank_1 = rocsolver_dpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotri_strided_batched_full_rank = rocsolver_cpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotri_strided_batched_rank_0 = rocsolver_cpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_cpotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cpotri_strided_batched_rank_1 = rocsolver_cpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotri_strided_batched_full_rank = rocsolver_zpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotri_strided_batched_rank_0 = rocsolver_zpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_zpotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zpotri_strided_batched_rank_1 = rocsolver_zpotri_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_sgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      real(c_float),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      real(c_float),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_sgesvd_full_rank = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_sgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: S
      real(c_float),target :: U
      integer(c_int) :: ldu
      real(c_float),target :: V
      integer(c_int) :: ldv
      real(c_float),target :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_sgesvd_rank_0 = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_sgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      real(c_float),target,dimension(:) :: U
      integer(c_int) :: ldu
      real(c_float),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_sgesvd_rank_1 = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_dgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      real(c_double),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      real(c_double),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_dgesvd_full_rank = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_dgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: S
      real(c_double),target :: U
      integer(c_int) :: ldu
      real(c_double),target :: V
      integer(c_int) :: ldv
      real(c_double),target :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_dgesvd_rank_0 = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_dgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      real(c_double),target,dimension(:) :: U
      integer(c_int) :: ldu
      real(c_double),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_dgesvd_rank_1 = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_cgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      complex(c_float_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      complex(c_float_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_cgesvd_full_rank = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_cgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: S
      complex(c_float_complex),target :: U
      integer(c_int) :: ldu
      complex(c_float_complex),target :: V
      integer(c_int) :: ldv
      real(c_float),target :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_cgesvd_rank_0 = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_cgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      complex(c_float_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      complex(c_float_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_float),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_cgesvd_rank_1 = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_zgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      complex(c_double_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      complex(c_double_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_zgesvd_full_rank = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_zgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: S
      complex(c_double_complex),target :: U
      integer(c_int) :: ldu
      complex(c_double_complex),target :: V
      integer(c_int) :: ldv
      real(c_double),target :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_zgesvd_rank_0 = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_zgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      complex(c_double_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      complex(c_double_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      real(c_double),target,dimension(:) :: E
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      !
      rocsolver_zgesvd_rank_1 = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo)
    end function

    function rocsolver_sgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_float),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_float),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesvd_batched_full_rank = rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_sgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: S
      integer(c_int64_t) :: strideS
      real(c_float),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_float),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesvd_batched_rank_0 = rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_sgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_float),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_float),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesvd_batched_rank_1 = rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_dgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_double),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_double),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesvd_batched_full_rank = rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_dgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: S
      integer(c_int64_t) :: strideS
      real(c_double),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_double),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesvd_batched_rank_0 = rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_dgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_double),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_double),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesvd_batched_rank_1 = rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_cgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_float_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_float_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesvd_batched_full_rank = rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_cgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: S
      integer(c_int64_t) :: strideS
      complex(c_float_complex),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_float_complex),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesvd_batched_rank_0 = rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_cgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_float_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_float_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesvd_batched_rank_1 = rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_zgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_double_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_double_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesvd_batched_full_rank = rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_zgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: S
      integer(c_int64_t) :: strideS
      complex(c_double_complex),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_double_complex),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesvd_batched_rank_0 = rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_zgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_double_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_double_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesvd_batched_rank_1 = rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_sgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_float),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_float),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesvd_strided_batched_full_rank = rocsolver_sgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_sgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: S
      integer(c_int64_t) :: strideS
      real(c_float),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_float),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesvd_strided_batched_rank_0 = rocsolver_sgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_sgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_float),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_float),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgesvd_strided_batched_rank_1 = rocsolver_sgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_dgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_double),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_double),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesvd_strided_batched_full_rank = rocsolver_dgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_dgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: S
      integer(c_int64_t) :: strideS
      real(c_double),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_double),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesvd_strided_batched_rank_0 = rocsolver_dgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_dgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      real(c_double),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      real(c_double),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgesvd_strided_batched_rank_1 = rocsolver_dgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_cgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_float_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_float_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesvd_strided_batched_full_rank = rocsolver_cgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_cgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: S
      integer(c_int64_t) :: strideS
      complex(c_float_complex),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_float_complex),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesvd_strided_batched_rank_0 = rocsolver_cgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_cgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_float_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_float_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgesvd_strided_batched_rank_1 = rocsolver_cgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_zgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_double_complex),target,dimension(:,:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_double_complex),target,dimension(:,:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesvd_strided_batched_full_rank = rocsolver_zgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_zgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: S
      integer(c_int64_t) :: strideS
      complex(c_double_complex),target :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_double_complex),target :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesvd_strided_batched_rank_0 = rocsolver_zgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_zgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_svect_all)) :: left_svect
      integer(kind(rocblas_svect_all)) :: right_svect
      integer(c_int) :: m
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: S
      integer(c_int64_t) :: strideS
      complex(c_double_complex),target,dimension(:) :: U
      integer(c_int) :: ldu
      integer(c_int64_t) :: strideU
      complex(c_double_complex),target,dimension(:) :: V
      integer(c_int) :: ldv
      integer(c_int64_t) :: strideV
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(kind(rocblas_outofplace)) :: fast_alg
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgesvd_strided_batched_rank_1 = rocsolver_zgesvd_strided_batched_(handle,left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count)
    end function

    function rocsolver_ssytd2_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float) :: tau
      !
      rocsolver_ssytd2_full_rank = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_ssytd2_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float) :: tau
      !
      rocsolver_ssytd2_rank_0 = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_ssytd2_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float) :: tau
      !
      rocsolver_ssytd2_rank_1 = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_dsytd2_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double) :: tau
      !
      rocsolver_dsytd2_full_rank = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_dsytd2_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double) :: tau
      !
      rocsolver_dsytd2_rank_0 = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_dsytd2_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double) :: tau
      !
      rocsolver_dsytd2_rank_1 = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_chetd2_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex) :: tau
      !
      rocsolver_chetd2_full_rank = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_chetd2_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex) :: tau
      !
      rocsolver_chetd2_rank_0 = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_chetd2_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex) :: tau
      !
      rocsolver_chetd2_rank_1 = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_zhetd2_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex) :: tau
      !
      rocsolver_zhetd2_full_rank = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_zhetd2_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex) :: tau
      !
      rocsolver_zhetd2_rank_0 = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_zhetd2_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex) :: tau
      !
      rocsolver_zhetd2_rank_1 = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_ssytd2_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytd2_batched_full_rank = rocsolver_ssytd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytd2_batched_rank_0 = rocsolver_ssytd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytd2_batched_rank_1 = rocsolver_ssytd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytd2_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytd2_batched_full_rank = rocsolver_dsytd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytd2_batched_rank_0 = rocsolver_dsytd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytd2_batched_rank_1 = rocsolver_dsytd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetd2_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetd2_batched_full_rank = rocsolver_chetd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetd2_batched_rank_0 = rocsolver_chetd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetd2_batched_rank_1 = rocsolver_chetd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetd2_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetd2_batched_full_rank = rocsolver_zhetd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetd2_batched_rank_0 = rocsolver_zhetd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetd2_batched_rank_1 = rocsolver_zhetd2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytd2_strided_batched_full_rank = rocsolver_ssytd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytd2_strided_batched_rank_0 = rocsolver_ssytd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytd2_strided_batched_rank_1 = rocsolver_ssytd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytd2_strided_batched_full_rank = rocsolver_dsytd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytd2_strided_batched_rank_0 = rocsolver_dsytd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytd2_strided_batched_rank_1 = rocsolver_dsytd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetd2_strided_batched_full_rank = rocsolver_chetd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetd2_strided_batched_rank_0 = rocsolver_chetd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetd2_strided_batched_rank_1 = rocsolver_chetd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetd2_strided_batched_full_rank = rocsolver_zhetd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetd2_strided_batched_rank_0 = rocsolver_zhetd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetd2_strided_batched_rank_1 = rocsolver_zhetd2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytrd_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float) :: tau
      !
      rocsolver_ssytrd_full_rank = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_ssytrd_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      real(c_float) :: tau
      !
      rocsolver_ssytrd_rank_0 = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_ssytrd_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      real(c_float) :: tau
      !
      rocsolver_ssytrd_rank_1 = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_dsytrd_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double) :: tau
      !
      rocsolver_dsytrd_full_rank = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_dsytrd_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      real(c_double) :: tau
      !
      rocsolver_dsytrd_rank_0 = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_dsytrd_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      real(c_double) :: tau
      !
      rocsolver_dsytrd_rank_1 = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_chetrd_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex) :: tau
      !
      rocsolver_chetrd_full_rank = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_chetrd_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      complex(c_float_complex) :: tau
      !
      rocsolver_chetrd_rank_0 = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_chetrd_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      complex(c_float_complex) :: tau
      !
      rocsolver_chetrd_rank_1 = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_zhetrd_full_rank(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex) :: tau
      !
      rocsolver_zhetrd_full_rank = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_zhetrd_rank_0(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      complex(c_double_complex) :: tau
      !
      rocsolver_zhetrd_rank_0 = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_zhetrd_rank_1(handle,uplo,n,A,lda,D,E,tau)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      complex(c_double_complex) :: tau
      !
      rocsolver_zhetrd_rank_1 = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau)
    end function

    function rocsolver_ssytrd_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrd_batched_full_rank = rocsolver_ssytrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrd_batched_rank_0 = rocsolver_ssytrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrd_batched_rank_1 = rocsolver_ssytrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytrd_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrd_batched_full_rank = rocsolver_dsytrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrd_batched_rank_0 = rocsolver_dsytrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrd_batched_rank_1 = rocsolver_dsytrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetrd_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetrd_batched_full_rank = rocsolver_chetrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetrd_batched_rank_0 = rocsolver_chetrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetrd_batched_rank_1 = rocsolver_chetrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetrd_batched_full_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetrd_batched_full_rank = rocsolver_zhetrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetrd_batched_rank_0 = rocsolver_zhetrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetrd_batched_rank_1 = rocsolver_zhetrd_batched_(handle,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrd_strided_batched_full_rank = rocsolver_ssytrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrd_strided_batched_rank_0 = rocsolver_ssytrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssytrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_float) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrd_strided_batched_rank_1 = rocsolver_ssytrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrd_strided_batched_full_rank = rocsolver_dsytrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrd_strided_batched_rank_0 = rocsolver_dsytrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_dsytrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      real(c_double) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrd_strided_batched_rank_1 = rocsolver_dsytrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetrd_strided_batched_full_rank = rocsolver_chetrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetrd_strided_batched_rank_0 = rocsolver_chetrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_chetrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_float_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_chetrd_strided_batched_rank_1 = rocsolver_chetrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetrd_strided_batched_full_rank = rocsolver_zhetrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetrd_strided_batched_rank_0 = rocsolver_zhetrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_zhetrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE,tau,strideP,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      complex(c_double_complex) :: tau
      integer(c_int64_t) :: strideP
      integer(c_int) :: batch_count
      !
      rocsolver_zhetrd_strided_batched_rank_1 = rocsolver_zhetrd_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,tau,strideP,batch_count)
    end function

    function rocsolver_ssygs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_ssygs2_full_rank = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_ssygs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_ssygs2_rank_0 = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_ssygs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_ssygs2_rank_1 = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dsygs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dsygs2_full_rank = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dsygs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_dsygs2_rank_0 = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dsygs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dsygs2_rank_1 = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_chegs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_chegs2_full_rank = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_chegs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_chegs2_rank_0 = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_chegs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_chegs2_rank_1 = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zhegs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zhegs2_full_rank = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zhegs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_zhegs2_rank_0 = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zhegs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zhegs2_rank_1 = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_ssygs2_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_ssygs2_batched_full_rank = rocsolver_ssygs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_ssygs2_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_ssygs2_batched_rank_0 = rocsolver_ssygs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_ssygs2_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_ssygs2_batched_rank_1 = rocsolver_ssygs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dsygs2_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dsygs2_batched_full_rank = rocsolver_dsygs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dsygs2_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dsygs2_batched_rank_0 = rocsolver_dsygs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dsygs2_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dsygs2_batched_rank_1 = rocsolver_dsygs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_chegs2_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_chegs2_batched_full_rank = rocsolver_chegs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_chegs2_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_chegs2_batched_rank_0 = rocsolver_chegs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_chegs2_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_chegs2_batched_rank_1 = rocsolver_chegs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zhegs2_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zhegs2_batched_full_rank = rocsolver_zhegs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zhegs2_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zhegs2_batched_rank_0 = rocsolver_zhegs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zhegs2_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zhegs2_batched_rank_1 = rocsolver_zhegs2_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_ssygs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_ssygs2_strided_batched_full_rank = rocsolver_ssygs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_ssygs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_ssygs2_strided_batched_rank_0 = rocsolver_ssygs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_ssygs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_ssygs2_strided_batched_rank_1 = rocsolver_ssygs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dsygs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dsygs2_strided_batched_full_rank = rocsolver_dsygs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dsygs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dsygs2_strided_batched_rank_0 = rocsolver_dsygs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dsygs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dsygs2_strided_batched_rank_1 = rocsolver_dsygs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_chegs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_chegs2_strided_batched_full_rank = rocsolver_chegs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_chegs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_chegs2_strided_batched_rank_0 = rocsolver_chegs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_chegs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_chegs2_strided_batched_rank_1 = rocsolver_chegs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zhegs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zhegs2_strided_batched_full_rank = rocsolver_zhegs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zhegs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zhegs2_strided_batched_rank_0 = rocsolver_zhegs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zhegs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zhegs2_strided_batched_rank_1 = rocsolver_zhegs2_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_ssygst_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_ssygst_full_rank = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_ssygst_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_ssygst_rank_0 = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_ssygst_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_ssygst_rank_1 = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dsygst_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dsygst_full_rank = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dsygst_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_dsygst_rank_0 = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_dsygst_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_dsygst_rank_1 = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_chegst_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_chegst_full_rank = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_chegst_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_chegst_rank_0 = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_chegst_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_chegst_rank_1 = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zhegst_full_rank(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zhegst_full_rank = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zhegst_rank_0(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      !
      rocsolver_zhegst_rank_0 = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_zhegst_rank_1(handle,itype,uplo,n,A,lda,B,ldb)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      !
      rocsolver_zhegst_rank_1 = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb)
    end function

    function rocsolver_ssygst_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_ssygst_batched_full_rank = rocsolver_ssygst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_ssygst_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_ssygst_batched_rank_0 = rocsolver_ssygst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_ssygst_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_ssygst_batched_rank_1 = rocsolver_ssygst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dsygst_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dsygst_batched_full_rank = rocsolver_dsygst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dsygst_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dsygst_batched_rank_0 = rocsolver_dsygst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_dsygst_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_dsygst_batched_rank_1 = rocsolver_dsygst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_chegst_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_chegst_batched_full_rank = rocsolver_chegst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_chegst_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_chegst_batched_rank_0 = rocsolver_chegst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_chegst_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_chegst_batched_rank_1 = rocsolver_chegst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zhegst_batched_full_rank(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zhegst_batched_full_rank = rocsolver_zhegst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zhegst_batched_rank_0(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zhegst_batched_rank_0 = rocsolver_zhegst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_zhegst_batched_rank_1(handle,itype,uplo,n,A,lda,B,ldb,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int) :: batch_count
      !
      rocsolver_zhegst_batched_rank_1 = rocsolver_zhegst_batched_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb,batch_count)
    end function

    function rocsolver_ssygst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_ssygst_strided_batched_full_rank = rocsolver_ssygst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_ssygst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_ssygst_strided_batched_rank_0 = rocsolver_ssygst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_ssygst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_ssygst_strided_batched_rank_1 = rocsolver_ssygst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dsygst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dsygst_strided_batched_full_rank = rocsolver_dsygst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dsygst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dsygst_strided_batched_rank_0 = rocsolver_dsygst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_dsygst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_dsygst_strided_batched_rank_1 = rocsolver_dsygst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_chegst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_chegst_strided_batched_full_rank = rocsolver_chegst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_chegst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_chegst_strided_batched_rank_0 = rocsolver_chegst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_chegst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_chegst_strided_batched_rank_1 = rocsolver_chegst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zhegst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zhegst_strided_batched_full_rank = rocsolver_zhegst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zhegst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zhegst_strided_batched_rank_0 = rocsolver_zhegst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_zhegst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      integer(c_int) :: batch_count
      !
      rocsolver_zhegst_strided_batched_rank_1 = rocsolver_zhegst_strided_batched_(handle,itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count)
    end function

    function rocsolver_ssyev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssyev_full_rank = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssyev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssyev_rank_0 = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssyev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssyev_rank_1 = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsyev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsyev_full_rank = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsyev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsyev_rank_0 = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsyev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsyev_rank_1 = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_cheev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_cheev_full_rank = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_cheev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_cheev_rank_0 = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_cheev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_cheev_rank_1 = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zheev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zheev_full_rank = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zheev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zheev_rank_0 = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zheev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zheev_rank_1 = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssyev_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyev_batched_full_rank = rocsolver_ssyev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyev_batched_rank_0 = rocsolver_ssyev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyev_batched_rank_1 = rocsolver_ssyev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyev_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyev_batched_full_rank = rocsolver_dsyev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyev_batched_rank_0 = rocsolver_dsyev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyev_batched_rank_1 = rocsolver_dsyev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheev_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheev_batched_full_rank = rocsolver_cheev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheev_batched_rank_0 = rocsolver_cheev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheev_batched_rank_1 = rocsolver_cheev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheev_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheev_batched_full_rank = rocsolver_zheev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheev_batched_rank_0 = rocsolver_zheev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheev_batched_rank_1 = rocsolver_zheev_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyev_strided_batched_full_rank = rocsolver_ssyev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyev_strided_batched_rank_0 = rocsolver_ssyev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyev_strided_batched_rank_1 = rocsolver_ssyev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyev_strided_batched_full_rank = rocsolver_dsyev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyev_strided_batched_rank_0 = rocsolver_dsyev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyev_strided_batched_rank_1 = rocsolver_dsyev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheev_strided_batched_full_rank = rocsolver_cheev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheev_strided_batched_rank_0 = rocsolver_cheev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheev_strided_batched_rank_1 = rocsolver_cheev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheev_strided_batched_full_rank = rocsolver_zheev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheev_strided_batched_rank_0 = rocsolver_zheev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheev_strided_batched_rank_1 = rocsolver_zheev_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssyevd_full_rank = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssyevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssyevd_rank_0 = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssyevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssyevd_rank_1 = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsyevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsyevd_full_rank = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsyevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsyevd_rank_0 = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsyevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsyevd_rank_1 = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_cheevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_cheevd_full_rank = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_cheevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_cheevd_rank_0 = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_cheevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_cheevd_rank_1 = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zheevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zheevd_full_rank = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zheevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zheevd_rank_0 = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zheevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zheevd_rank_1 = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssyevd_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyevd_batched_full_rank = rocsolver_ssyevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyevd_batched_rank_0 = rocsolver_ssyevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyevd_batched_rank_1 = rocsolver_ssyevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyevd_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyevd_batched_full_rank = rocsolver_dsyevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyevd_batched_rank_0 = rocsolver_dsyevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyevd_batched_rank_1 = rocsolver_dsyevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheevd_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheevd_batched_full_rank = rocsolver_cheevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheevd_batched_rank_0 = rocsolver_cheevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheevd_batched_rank_1 = rocsolver_cheevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheevd_batched_full_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheevd_batched_full_rank = rocsolver_zheevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheevd_batched_rank_0 = rocsolver_zheevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheevd_batched_rank_1 = rocsolver_zheevd_batched_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyevd_strided_batched_full_rank = rocsolver_ssyevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyevd_strided_batched_rank_0 = rocsolver_ssyevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssyevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssyevd_strided_batched_rank_1 = rocsolver_ssyevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyevd_strided_batched_full_rank = rocsolver_dsyevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyevd_strided_batched_rank_0 = rocsolver_dsyevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsyevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsyevd_strided_batched_rank_1 = rocsolver_dsyevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheevd_strided_batched_full_rank = rocsolver_cheevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheevd_strided_batched_rank_0 = rocsolver_cheevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_cheevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cheevd_strided_batched_rank_1 = rocsolver_cheevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheevd_strided_batched_full_rank = rocsolver_zheevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheevd_strided_batched_rank_0 = rocsolver_zheevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zheevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zheevd_strided_batched_rank_1 = rocsolver_zheevd_strided_batched_(handle,evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssygv_full_rank = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssygv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssygv_rank_0 = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssygv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssygv_rank_1 = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsygv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsygv_full_rank = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsygv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsygv_rank_0 = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsygv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsygv_rank_1 = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_chegv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_chegv_full_rank = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_chegv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_chegv_rank_0 = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_chegv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_chegv_rank_1 = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zhegv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zhegv_full_rank = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zhegv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zhegv_rank_0 = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zhegv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zhegv_rank_1 = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssygv_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygv_batched_full_rank = rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygv_batched_rank_0 = rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygv_batched_rank_1 = rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygv_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygv_batched_full_rank = rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygv_batched_rank_0 = rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygv_batched_rank_1 = rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegv_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegv_batched_full_rank = rocsolver_chegv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegv_batched_rank_0 = rocsolver_chegv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegv_batched_rank_1 = rocsolver_chegv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegv_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegv_batched_full_rank = rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegv_batched_rank_0 = rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegv_batched_rank_1 = rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygv_strided_batched_full_rank = rocsolver_ssygv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygv_strided_batched_rank_0 = rocsolver_ssygv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygv_strided_batched_rank_1 = rocsolver_ssygv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygv_strided_batched_full_rank = rocsolver_dsygv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygv_strided_batched_rank_0 = rocsolver_dsygv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygv_strided_batched_rank_1 = rocsolver_dsygv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegv_strided_batched_full_rank = rocsolver_chegv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegv_strided_batched_rank_0 = rocsolver_chegv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegv_strided_batched_rank_1 = rocsolver_chegv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegv_strided_batched_full_rank = rocsolver_zhegv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegv_strided_batched_rank_0 = rocsolver_zhegv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegv_strided_batched_rank_1 = rocsolver_zhegv_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssygvd_full_rank = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssygvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssygvd_rank_0 = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssygvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_ssygvd_rank_1 = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsygvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsygvd_full_rank = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsygvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsygvd_rank_0 = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_dsygvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_dsygvd_rank_1 = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_chegvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_chegvd_full_rank = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_chegvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      real(c_float),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_chegvd_rank_0 = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_chegvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      real(c_float),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_chegvd_rank_1 = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zhegvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zhegvd_full_rank = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zhegvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      real(c_double),target :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zhegvd_rank_0 = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_zhegvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      real(c_double),target,dimension(:) :: E
      integer(c_int) :: myInfo
      !
      rocsolver_zhegvd_rank_1 = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),c_loc(E),myInfo)
    end function

    function rocsolver_ssygvd_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygvd_batched_full_rank = rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygvd_batched_rank_0 = rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygvd_batched_rank_1 = rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygvd_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygvd_batched_full_rank = rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygvd_batched_rank_0 = rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygvd_batched_rank_1 = rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegvd_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegvd_batched_full_rank = rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegvd_batched_rank_0 = rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegvd_batched_rank_1 = rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegvd_batched_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegvd_batched_full_rank = rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegvd_batched_rank_0 = rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegvd_batched_rank_1 = rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygvd_strided_batched_full_rank = rocsolver_ssygvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygvd_strided_batched_rank_0 = rocsolver_ssygvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_ssygvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssygvd_strided_batched_rank_1 = rocsolver_ssygvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygvd_strided_batched_full_rank = rocsolver_dsygvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygvd_strided_batched_rank_0 = rocsolver_dsygvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_dsygvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsygvd_strided_batched_rank_1 = rocsolver_dsygvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegvd_strided_batched_full_rank = rocsolver_chegvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target :: D
      integer(c_int64_t) :: strideD
      real(c_float),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegvd_strided_batched_rank_0 = rocsolver_chegvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_chegvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_float),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_float),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_chegvd_strided_batched_rank_1 = rocsolver_chegvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegvd_strided_batched_full_rank = rocsolver_zhegvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target :: D
      integer(c_int64_t) :: strideD
      real(c_double),target :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegvd_strided_batched_rank_0 = rocsolver_zhegvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_zhegvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_eform_ax)) :: itype
      integer(kind(rocblas_evect_original)) :: evect
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: B
      integer(c_int) :: ldb
      integer(c_int64_t) :: strideB
      real(c_double),target,dimension(:) :: D
      integer(c_int64_t) :: strideD
      real(c_double),target,dimension(:) :: E
      integer(c_int64_t) :: strideE
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zhegvd_strided_batched_rank_1 = rocsolver_zhegvd_strided_batched_(handle,itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count)
    end function

    function rocsolver_sgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_outofplace_full_rank = rocsolver_sgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_outofplace_rank_0 = rocsolver_sgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_outofplace_rank_1 = rocsolver_sgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_outofplace_full_rank = rocsolver_dgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_outofplace_rank_0 = rocsolver_dgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_outofplace_rank_1 = rocsolver_dgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_outofplace_full_rank = rocsolver_cgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_outofplace_rank_0 = rocsolver_cgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_outofplace_rank_1 = rocsolver_cgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_outofplace_full_rank = rocsolver_zgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_outofplace_rank_0 = rocsolver_zgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_outofplace_rank_1 = rocsolver_zgetri_outofplace_(handle,n,c_loc(A),lda,c_loc(ipiv),c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetri_outofplace_batched_full_rank(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_outofplace_batched_full_rank = rocsolver_sgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_sgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_outofplace_batched_rank_0 = rocsolver_sgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_sgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_outofplace_batched_rank_1 = rocsolver_sgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_dgetri_outofplace_batched_full_rank(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_outofplace_batched_full_rank = rocsolver_dgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_dgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_outofplace_batched_rank_0 = rocsolver_dgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_dgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_outofplace_batched_rank_1 = rocsolver_dgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_cgetri_outofplace_batched_full_rank(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_outofplace_batched_full_rank = rocsolver_cgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_cgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_outofplace_batched_rank_0 = rocsolver_cgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_cgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_outofplace_batched_rank_1 = rocsolver_cgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_zgetri_outofplace_batched_full_rank(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_outofplace_batched_full_rank = rocsolver_zgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_zgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_outofplace_batched_rank_0 = rocsolver_zgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_zgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_outofplace_batched_rank_1 = rocsolver_zgetri_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(ipiv),strideP,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_sgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_outofplace_strided_batched_full_rank = rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_sgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_outofplace_strided_batched_rank_0 = rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_sgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_outofplace_strided_batched_rank_1 = rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_dgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_outofplace_strided_batched_full_rank = rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_dgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_outofplace_strided_batched_rank_0 = rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_dgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_outofplace_strided_batched_rank_1 = rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_cgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_outofplace_strided_batched_full_rank = rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_cgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_outofplace_strided_batched_rank_0 = rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_cgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_outofplace_strided_batched_rank_1 = rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_zgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_outofplace_strided_batched_full_rank = rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_zgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_outofplace_strided_batched_rank_0 = rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_zgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_outofplace_strided_batched_rank_1 = rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_npvt_outofplace_full_rank = rocsolver_sgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_npvt_outofplace_rank_0 = rocsolver_sgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_sgetri_npvt_outofplace_rank_1 = rocsolver_sgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_npvt_outofplace_full_rank = rocsolver_dgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_npvt_outofplace_rank_0 = rocsolver_dgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_dgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_dgetri_npvt_outofplace_rank_1 = rocsolver_dgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_npvt_outofplace_full_rank = rocsolver_cgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_npvt_outofplace_rank_0 = rocsolver_cgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_cgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_cgetri_npvt_outofplace_rank_1 = rocsolver_cgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_npvt_outofplace_full_rank = rocsolver_zgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_npvt_outofplace_rank_0 = rocsolver_zgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_zgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      !
      rocsolver_zgetri_npvt_outofplace_rank_1 = rocsolver_zgetri_npvt_outofplace_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo)
    end function

    function rocsolver_sgetri_npvt_outofplace_batched_full_rank(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_outofplace_batched_full_rank = rocsolver_sgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_outofplace_batched_rank_0(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_outofplace_batched_rank_0 = rocsolver_sgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_outofplace_batched_rank_1(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_outofplace_batched_rank_1 = rocsolver_sgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_outofplace_batched_full_rank(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_outofplace_batched_full_rank = rocsolver_dgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_outofplace_batched_rank_0(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_outofplace_batched_rank_0 = rocsolver_dgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_outofplace_batched_rank_1(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_outofplace_batched_rank_1 = rocsolver_dgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_outofplace_batched_full_rank(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_outofplace_batched_full_rank = rocsolver_cgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_outofplace_batched_rank_0(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_outofplace_batched_rank_0 = rocsolver_cgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_outofplace_batched_rank_1(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_outofplace_batched_rank_1 = rocsolver_cgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_outofplace_batched_full_rank(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:,:,:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_outofplace_batched_full_rank = rocsolver_zgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_outofplace_batched_rank_0(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_outofplace_batched_rank_0 = rocsolver_zgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_outofplace_batched_rank_1(handle,n,A,lda,C,ldc,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_outofplace_batched_rank_1 = rocsolver_zgetri_npvt_outofplace_batched_(handle,n,c_loc(A),lda,c_loc(C),ldc,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank = rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0 = rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_float),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1 = rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank = rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0 = rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      real(c_double),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1 = rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank = rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0 = rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_float_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1 = rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:,:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank = rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0 = rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc,strideC,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      complex(c_double_complex),target,dimension(:) :: C
      integer(c_int) :: ldc
      integer(c_int64_t) :: strideC
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1 = rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C),ldc,strideC,myInfo,batch_count)
    end function

    function rocsolver_strtri_full_rank(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_strtri_full_rank = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_strtri_rank_0(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_strtri_rank_0 = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_strtri_rank_1(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_strtri_rank_1 = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dtrtri_full_rank(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dtrtri_full_rank = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dtrtri_rank_0(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dtrtri_rank_0 = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_dtrtri_rank_1(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_dtrtri_rank_1 = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_ctrtri_full_rank(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_ctrtri_full_rank = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_ctrtri_rank_0(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_ctrtri_rank_0 = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_ctrtri_rank_1(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_ctrtri_rank_1 = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_ztrtri_full_rank(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_ztrtri_full_rank = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_ztrtri_rank_0(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_ztrtri_rank_0 = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_ztrtri_rank_1(handle,uplo,diag,n,A,lda,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      !
      rocsolver_ztrtri_rank_1 = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo)
    end function

    function rocsolver_strtri_batched_full_rank(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_strtri_batched_full_rank = rocsolver_strtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_strtri_batched_rank_0(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_strtri_batched_rank_0 = rocsolver_strtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_strtri_batched_rank_1(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_strtri_batched_rank_1 = rocsolver_strtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dtrtri_batched_full_rank(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dtrtri_batched_full_rank = rocsolver_dtrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dtrtri_batched_rank_0(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dtrtri_batched_rank_0 = rocsolver_dtrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_dtrtri_batched_rank_1(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dtrtri_batched_rank_1 = rocsolver_dtrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_ctrtri_batched_full_rank(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ctrtri_batched_full_rank = rocsolver_ctrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_ctrtri_batched_rank_0(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ctrtri_batched_rank_0 = rocsolver_ctrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_ctrtri_batched_rank_1(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ctrtri_batched_rank_1 = rocsolver_ctrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_ztrtri_batched_full_rank(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ztrtri_batched_full_rank = rocsolver_ztrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_ztrtri_batched_rank_0(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ztrtri_batched_rank_0 = rocsolver_ztrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_ztrtri_batched_rank_1(handle,uplo,diag,n,A,lda,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ztrtri_batched_rank_1 = rocsolver_ztrtri_batched_(handle,uplo,diag,n,c_loc(A),lda,myInfo,batch_count)
    end function

    function rocsolver_strtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_strtri_strided_batched_full_rank = rocsolver_strtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_strtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_strtri_strided_batched_rank_0 = rocsolver_strtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_strtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_strtri_strided_batched_rank_1 = rocsolver_strtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dtrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dtrtri_strided_batched_full_rank = rocsolver_dtrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dtrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dtrtri_strided_batched_rank_0 = rocsolver_dtrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_dtrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dtrtri_strided_batched_rank_1 = rocsolver_dtrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ctrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ctrtri_strided_batched_full_rank = rocsolver_ctrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ctrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ctrtri_strided_batched_rank_0 = rocsolver_ctrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ctrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ctrtri_strided_batched_rank_1 = rocsolver_ctrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ztrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ztrtri_strided_batched_full_rank = rocsolver_ztrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ztrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ztrtri_strided_batched_rank_0 = rocsolver_ztrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ztrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(kind(rocblas_diagonal_non_unit)) :: diag
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ztrtri_strided_batched_rank_1 = rocsolver_ztrtri_strided_batched_(handle,uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count)
    end function

    function rocsolver_ssytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_ssytf2_full_rank = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_ssytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_ssytf2_rank_0 = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_ssytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_ssytf2_rank_1 = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dsytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dsytf2_full_rank = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dsytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dsytf2_rank_0 = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dsytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dsytf2_rank_1 = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_csytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_csytf2_full_rank = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_csytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_csytf2_rank_0 = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_csytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_csytf2_rank_1 = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zsytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zsytf2_full_rank = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zsytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zsytf2_rank_0 = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zsytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zsytf2_rank_1 = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_ssytf2_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytf2_batched_full_rank = rocsolver_ssytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytf2_batched_rank_0 = rocsolver_ssytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytf2_batched_rank_1 = rocsolver_ssytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytf2_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytf2_batched_full_rank = rocsolver_dsytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytf2_batched_rank_0 = rocsolver_dsytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytf2_batched_rank_1 = rocsolver_dsytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytf2_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytf2_batched_full_rank = rocsolver_csytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytf2_batched_rank_0 = rocsolver_csytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytf2_batched_rank_1 = rocsolver_csytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytf2_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytf2_batched_full_rank = rocsolver_zsytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytf2_batched_rank_0 = rocsolver_zsytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytf2_batched_rank_1 = rocsolver_zsytf2_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytf2_strided_batched_full_rank = rocsolver_ssytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytf2_strided_batched_rank_0 = rocsolver_ssytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytf2_strided_batched_rank_1 = rocsolver_ssytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytf2_strided_batched_full_rank = rocsolver_dsytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytf2_strided_batched_rank_0 = rocsolver_dsytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytf2_strided_batched_rank_1 = rocsolver_dsytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytf2_strided_batched_full_rank = rocsolver_csytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytf2_strided_batched_rank_0 = rocsolver_csytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytf2_strided_batched_rank_1 = rocsolver_csytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytf2_strided_batched_full_rank = rocsolver_zsytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytf2_strided_batched_rank_0 = rocsolver_zsytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytf2_strided_batched_rank_1 = rocsolver_zsytf2_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_ssytrf_full_rank = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_ssytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_ssytrf_rank_0 = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_ssytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_ssytrf_rank_1 = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dsytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dsytrf_full_rank = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dsytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dsytrf_rank_0 = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_dsytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_dsytrf_rank_1 = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_csytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_csytrf_full_rank = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_csytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_csytrf_rank_0 = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_csytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_csytrf_rank_1 = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zsytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zsytrf_full_rank = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zsytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zsytrf_rank_0 = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_zsytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int) :: myInfo
      !
      rocsolver_zsytrf_rank_1 = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo)
    end function

    function rocsolver_ssytrf_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrf_batched_full_rank = rocsolver_ssytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrf_batched_rank_0 = rocsolver_ssytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrf_batched_rank_1 = rocsolver_ssytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytrf_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrf_batched_full_rank = rocsolver_dsytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrf_batched_rank_0 = rocsolver_dsytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrf_batched_rank_1 = rocsolver_dsytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytrf_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytrf_batched_full_rank = rocsolver_csytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytrf_batched_rank_0 = rocsolver_csytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytrf_batched_rank_1 = rocsolver_csytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytrf_batched_full_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:,:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytrf_batched_full_rank = rocsolver_zsytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytrf_batched_rank_0 = rocsolver_zsytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytrf_batched_rank_1 = rocsolver_zsytrf_batched_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrf_strided_batched_full_rank = rocsolver_ssytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrf_strided_batched_rank_0 = rocsolver_ssytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_ssytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_float),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_ssytrf_strided_batched_rank_1 = rocsolver_ssytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrf_strided_batched_full_rank = rocsolver_dsytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrf_strided_batched_rank_0 = rocsolver_dsytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_dsytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      real(c_double),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_dsytrf_strided_batched_rank_1 = rocsolver_dsytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytrf_strided_batched_full_rank = rocsolver_csytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytrf_strided_batched_rank_0 = rocsolver_csytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_csytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_float_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_csytrf_strided_batched_rank_1 = rocsolver_csytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_full_rank
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:,:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytrf_strided_batched_full_rank = rocsolver_zsytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_rank_0
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytrf_strided_batched_rank_0 = rocsolver_zsytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

    function rocsolver_zsytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo,batch_count)
      use iso_c_binding
      use hipfort_rocsolver_enums
      use hipfort_rocblas_enums
      implicit none
      integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_rank_1
      type(c_ptr) :: handle
      integer(kind(rocblas_fill_upper)) :: uplo
      integer(c_int) :: n
      complex(c_double_complex),target,dimension(:) :: A
      integer(c_int) :: lda
      integer(c_int64_t) :: strideA
      integer(c_int),target,dimension(:) :: ipiv
      integer(c_int64_t) :: strideP
      integer(c_int) :: myInfo
      integer(c_int) :: batch_count
      !
      rocsolver_zsytrf_strided_batched_rank_1 = rocsolver_zsytrf_strided_batched_(handle,uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count)
    end function

  
#endif
end module hipfort_rocsolver
